sea-chart 2.0.37 → 2.0.38

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

@@ -1,56 +1,50 @@
-"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 => {
+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 => {
   let {
     type,
     data
   } = column;
   switch (type) {
-    case _dtableUtils.CellType.DATE:
+    case CellType.DATE:
       {
         let isShowHourAndMinute = data && data.format && data.format.indexOf('HH:mm') > -1;
         return isShowHourAndMinute ? 160 : 100;
       }
-    case _dtableUtils.CellType.CTIME:
-    case _dtableUtils.CellType.MTIME:
-    case _dtableUtils.CellType.LINK:
-    case _dtableUtils.CellType.GEOLOCATION:
+    case CellType.CTIME:
+    case CellType.MTIME:
+    case CellType.LINK:
+    case CellType.GEOLOCATION:
       {
         return 160;
       }
-    case _dtableUtils.CellType.COLLABORATOR:
+    case CellType.COLLABORATOR:
       {
         return 100;
       }
-    case _dtableUtils.CellType.CHECKBOX:
+    case CellType.CHECKBOX:
       {
         return 40;
       }
-    case _dtableUtils.CellType.NUMBER:
-    case _dtableUtils.CellType.AUTO_NUMBER:
+    case CellType.NUMBER:
+    case CellType.AUTO_NUMBER:
       {
         return 120;
       }
@@ -60,8 +54,7 @@ const getCellRecordWidth = column => {
       }
   }
 };
-exports.getCellRecordWidth = getCellRecordWidth;
-const getRowRecord = function (currentTableId, row, columns, unShowColumnKeyList) {
+export const getRowRecord = function (currentTableId, row, columns, unShowColumnKeyList) {
   let matchedResult = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
   if (!Array.isArray(unShowColumnKeyList)) {
     unShowColumnKeyList = [];
@@ -78,62 +71,60 @@ const getRowRecord = function (currentTableId, row, columns, unShowColumnKeyList
     }, column.width);
   });
 };
-exports.getRowRecord = getRowRecord;
-const isLookupImages = column => {
+export const isLookupImages = column => {
   const {
     type,
     data
   } = column;
-  if (type !== _dtableUtils.CellType.LINK_FORMULA) return false;
+  if (type !== CellType.LINK_FORMULA) return false;
   const {
     result_type,
     array_type
   } = data || {};
-  if (result_type !== _dtableUtils.FORMULA_RESULT_TYPE.ARRAY) return false;
-  return array_type === _dtableUtils.CellType.IMAGE || array_type === _dtableUtils.CellType.DIGITAL_SIGN;
+  if (result_type !== FORMULA_RESULT_TYPE.ARRAY) return false;
+  return array_type === CellType.IMAGE || array_type === CellType.DIGITAL_SIGN;
 };
-exports.isLookupImages = isLookupImages;
 function _getCellRecord(displayValue, rowId, column, columnWidth) {
   let {
     key
   } = column;
-  return /*#__PURE__*/_react.default.createElement("div", {
+  return /*#__PURE__*/React.createElement("div", {
     className: "row-cell-value text-truncate",
     key: rowId + '_' + key,
     style: {
       width: columnWidth
     }
-  }, displayValue ? displayValue : /*#__PURE__*/_react.default.createElement("span", {
+  }, displayValue ? displayValue : /*#__PURE__*/React.createElement("span", {
     className: "row-cell-value-empty"
   }));
 }
 function _renderSearch(value, searchValue) {
-  return /*#__PURE__*/_react.default.createElement("span", {
+  return /*#__PURE__*/React.createElement("span", {
     className: "cell-value-ellipsis text-truncate",
     title: value
-  }, /*#__PURE__*/_react.default.createElement(_highlighter.default, {
+  }, /*#__PURE__*/React.createElement(Highlighter, {
     highlight: searchValue
   }, value));
 }
 function getLookupImagesDOMs(value, arrayType) {
   if (!value) return null;
   let images = Array.isArray(value) ? value : [value];
-  if (arrayType === _dtableUtils.CellType.DIGITAL_SIGN) {
-    images = value.map(sign => _digitalSignUtils.default.getSignImageUrl(sign)).filter(Boolean);
+  if (arrayType === CellType.DIGITAL_SIGN) {
+    images = value.map(sign => DigitalSignUtils.getSignImageUrl(sign)).filter(Boolean);
   }
   const amount = images.length;
   if (amount === 0) return null;
-  const imgSrc = (0, _commonUtils.getImageThumbnailUrl)(images[0]);
-  return /*#__PURE__*/_react.default.createElement("div", {
+  const imgSrc = getImageThumbnailUrl(images[0]);
+  return /*#__PURE__*/React.createElement("div", {
     className: "image-cell-value"
-  }, /*#__PURE__*/_react.default.createElement("img", {
+  }, /*#__PURE__*/React.createElement("img", {
     alt: "",
     src: imgSrc
-  }), amount > 1 && /*#__PURE__*/_react.default.createElement("span", {
+  }), amount > 1 && /*#__PURE__*/React.createElement("span", {
     className: "cell-value-size"
   }, '+' + amount));
 }
-const getFormattedCell = function (column, row) {
+export const getFormattedCell = function (column, row) {
   let {
     formulaRow = {},
     searchValue = null,
@@ -150,15 +141,15 @@ const getFormattedCell = function (column, row) {
   let value = row[key];
   let displayValue;
   let isNonEmptyArray = Array.isArray(value) && value.length > 0;
-  const departments = _context.default.getDepartments();
+  const departments = context.getDepartments();
   switch (type) {
-    case _dtableUtils.CellType.TEXT:
+    case CellType.TEXT:
       {
         if (value && typeof value === 'string') {
           if (searchValue) {
             displayValue = _renderSearch(value, searchValue);
           } else {
-            displayValue = /*#__PURE__*/_react.default.createElement("span", {
+            displayValue = /*#__PURE__*/React.createElement("span", {
               className: "cell-value-ellipsis text-truncate",
               title: value
             }, value);
@@ -166,59 +157,59 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.DATE:
+    case CellType.DATE:
       {
         if (value && typeof value === 'string') {
           const format = column.data && column.data.format ? column.data.format : 'YYYY-MM-DD';
-          const formatValue = (0, _dtableUtils.getDateDisplayString)(value, format);
+          const formatValue = getDateDisplayString(value, format);
           displayValue = searchValue ? _renderSearch(formatValue, searchValue) : formatValue;
         }
         break;
       }
-    case _dtableUtils.CellType.CTIME:
-    case _dtableUtils.CellType.MTIME:
+    case CellType.CTIME:
+    case CellType.MTIME:
       {
         if (value && typeof value === 'string') {
           if (searchValue) {
-            displayValue = /*#__PURE__*/_react.default.createElement(_highlighter.default, {
+            displayValue = /*#__PURE__*/React.createElement(Highlighter, {
               highlight: searchValue
-            }, (0, _dayjs.default)(value).format('YYYY-MM-DD HH:mm:ss'));
+            }, dayjs(value).format('YYYY-MM-DD HH:mm:ss'));
           } else {
-            displayValue = (0, _dayjs.default)(value).format('YYYY-MM-DD HH:mm:ss');
+            displayValue = dayjs(value).format('YYYY-MM-DD HH:mm:ss');
           }
         }
         break;
       }
-    case _dtableUtils.CellType.NUMBER:
+    case CellType.NUMBER:
       {
-        if ((0, _dtableUtils.isNumber)(value)) {
+        if (isNumber(value)) {
           const {
             data = {}
           } = column;
-          const formatedValue = (0, _dtableUtils.getNumberDisplayString)(value, data);
+          const formatedValue = getNumberDisplayString(value, data);
           if (searchValue) {
             displayValue = _renderSearch(formatedValue, searchValue);
           } else {
-            displayValue = /*#__PURE__*/_react.default.createElement("div", {
+            displayValue = /*#__PURE__*/React.createElement("div", {
               className: "number-formatter"
             }, formatedValue);
           }
         }
         break;
       }
-    case _dtableUtils.CellType.LINK:
+    case CellType.LINK:
       {
         displayValue = null;
         const {
           data
         } = column;
-        if (!(0, _dtableUtils.isValidLink)(data)) break;
+        if (!isValidLink(data)) break;
 
         // is default view: row data can get from formula row
         // is archive view: row data can get form rowdata
-        value = (0, _commonUtils.isArchiveViewRowData)(row, column) ? value : formulaRow[key];
+        value = isArchiveViewRowData(row, column) ? value : formulaRow[key];
         if (!value || !Array.isArray(value) || value.length === 0) break;
-        const collaborators = _context.default.getCollaboratorsFromCache();
+        const collaborators = context.getCollaboratorsFromCache();
         const {
           display_column_key,
           array_type,
@@ -230,9 +221,9 @@ const getFormattedCell = function (column, row) {
           type: array_type,
           data: array_data
         };
-        displayValue = /*#__PURE__*/_react.default.createElement("div", {
+        displayValue = /*#__PURE__*/React.createElement("div", {
           className: "links-formatter"
-        }, /*#__PURE__*/_react.default.createElement("div", {
+        }, /*#__PURE__*/React.createElement("div", {
           className: "formatter-show"
         }, value.map(item => {
           const {
@@ -246,24 +237,24 @@ const getFormattedCell = function (column, row) {
           const formulaRows = {
             [rowId]: linkedRow
           };
-          const displayResult = (0, _dtableUtils.getCellValueStringResult)(linkedRow, linkedColumn, {
+          const displayResult = getCellValueStringResult(linkedRow, linkedColumn, {
             formulaRows,
             collaborators,
             departments
           });
-          return /*#__PURE__*/_react.default.createElement("div", {
-            key: "".concat(rowId, "_").concat(display_column_key),
+          return /*#__PURE__*/React.createElement("div", {
+            key: `${rowId}_${display_column_key}`,
             className: "link"
-          }, /*#__PURE__*/_react.default.createElement("span", {
+          }, /*#__PURE__*/React.createElement("span", {
             className: "link-name"
           }, displayResult));
         })));
         break;
       }
-    case _dtableUtils.CellType.COLLABORATOR:
+    case CellType.COLLABORATOR:
       {
         if (value && isNonEmptyArray) {
-          const allCollaborators = _context.default.getCollaboratorsFromCache();
+          const allCollaborators = context.getCollaboratorsFromCache();
           let validValue = value.filter(item => {
             return allCollaborators.find(collaborator => collaborator.email === item);
           });
@@ -275,81 +266,81 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.SINGLE_SELECT:
+    case CellType.SINGLE_SELECT:
       {
         if (value && typeof value === 'string') {
-          displayValue = /*#__PURE__*/_react.default.createElement(_SingleSelectOption.default, {
+          displayValue = /*#__PURE__*/React.createElement(SingleSelectOption, {
             column: column,
             value: value
           });
         }
         break;
       }
-    case _dtableUtils.CellType.MULTIPLE_SELECT:
+    case CellType.MULTIPLE_SELECT:
       {
         if (value && isNonEmptyArray) {
-          displayValue = /*#__PURE__*/_react.default.createElement("span", {
+          displayValue = /*#__PURE__*/React.createElement("span", {
             className: "multiple-select-formatter"
           }, value.map((item, index) => {
-            return /*#__PURE__*/_react.default.createElement(_SingleSelectOption.default, {
+            return /*#__PURE__*/React.createElement(SingleSelectOption, {
               column: column,
               value: item,
-              key: "row-operation-multiple-select-".concat(index)
+              key: `row-operation-multiple-select-${index}`
             });
           }));
         }
         break;
       }
-    case _dtableUtils.CellType.FILE:
+    case CellType.FILE:
       {
         if (value && isNonEmptyArray) {
           let {
             name,
             type
           } = value[0];
-          let fileIconUrl = (0, _commonUtils.getFileIconUrl)(name, type);
+          let fileIconUrl = getFileIconUrl(name, type);
           let amount = value.length;
-          displayValue = /*#__PURE__*/_react.default.createElement("div", {
+          displayValue = /*#__PURE__*/React.createElement("div", {
             className: "image-cell-value"
-          }, /*#__PURE__*/_react.default.createElement("img", {
+          }, /*#__PURE__*/React.createElement("img", {
             alt: "",
             src: fileIconUrl
-          }), amount > 1 && /*#__PURE__*/_react.default.createElement("span", {
+          }), amount > 1 && /*#__PURE__*/React.createElement("span", {
             className: "cell-value-size"
           }, '+' + amount));
         }
         break;
       }
-    case _dtableUtils.CellType.IMAGE:
+    case CellType.IMAGE:
       {
         if (value && isNonEmptyArray) {
-          const imgSrc = (0, _commonUtils.getImageThumbnailUrl)(value[0]);
+          const imgSrc = getImageThumbnailUrl(value[0]);
           const amount = value.length;
-          displayValue = /*#__PURE__*/_react.default.createElement("div", {
+          displayValue = /*#__PURE__*/React.createElement("div", {
             className: "image-cell-value"
-          }, /*#__PURE__*/_react.default.createElement("img", {
+          }, /*#__PURE__*/React.createElement("img", {
             alt: "",
             src: imgSrc
-          }), amount > 1 && /*#__PURE__*/_react.default.createElement("span", {
+          }), amount > 1 && /*#__PURE__*/React.createElement("span", {
             className: "cell-value-size"
           }, '+' + amount));
         }
         break;
       }
-    case _dtableUtils.CellType.DIGITAL_SIGN:
+    case CellType.DIGITAL_SIGN:
       {
-        const signImageUrl = (0, _commonUtils.getImageThumbnailUrl)(_digitalSignUtils.default.getSignImageUrl(value));
+        const signImageUrl = getImageThumbnailUrl(DigitalSignUtils.getSignImageUrl(value));
         if (signImageUrl) {
-          displayValue = /*#__PURE__*/_react.default.createElement("div", {
+          displayValue = /*#__PURE__*/React.createElement("div", {
             className: "image-cell-value"
-          }, /*#__PURE__*/_react.default.createElement("img", {
+          }, /*#__PURE__*/React.createElement("img", {
             src: signImageUrl,
             alt: ""
           }));
         }
         break;
       }
-    case _dtableUtils.CellType.DEPARTMENT_SINGLE_SELECT:
+    case CellType.DEPARTMENT_SINGLE_SELECT:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -359,10 +350,10 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.CHECKBOX:
+    case CellType.CHECKBOX:
       {
         if (value) {
-          displayValue = /*#__PURE__*/_react.default.createElement("span", {
+          displayValue = /*#__PURE__*/React.createElement("span", {
             className: "dtable-font dtable-icon-check-mark",
             style: {
               color: '#20c933'
@@ -371,10 +362,10 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.GEOLOCATION:
+    case CellType.GEOLOCATION:
       {
         if (value && typeof value === 'object') {
-          displayValue = /*#__PURE__*/_react.default.createElement("div", {
+          displayValue = /*#__PURE__*/React.createElement("div", {
             className: "geolocation-formatter"
           }, createColumnFormatter(type, {
             value,
@@ -385,10 +376,10 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.CREATOR:
-    case _dtableUtils.CellType.LAST_MODIFIER:
+    case CellType.CREATOR:
+    case CellType.LAST_MODIFIER:
       {
-        const collaborators = _context.default.getCollaboratorsFromCache();
+        const collaborators = context.getCollaboratorsFromCache();
         if (value) {
           displayValue = createColumnFormatter(type, {
             value,
@@ -397,7 +388,7 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.LONG_TEXT:
+    case CellType.LONG_TEXT:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -407,8 +398,8 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.FORMULA:
-    case _dtableUtils.CellType.LINK_FORMULA:
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
       {
         if (!formulaRow) {
           break;
@@ -419,7 +410,7 @@ const getFormattedCell = function (column, row) {
           displayValue = getLookupImagesDOMs(newValue, column.data.array_type);
           break;
         }
-        const collaborators = _context.default.getCollaboratorsFromCache();
+        const collaborators = context.getCollaboratorsFromCache();
         let formatterProps = {
           value: newValue,
           column,
@@ -432,9 +423,9 @@ const getFormattedCell = function (column, row) {
         break;
       }
     // email, url, audo_number are same
-    case _dtableUtils.CellType.EMAIL:
-    case _dtableUtils.CellType.URL:
-    case _dtableUtils.CellType.AUTO_NUMBER:
+    case CellType.EMAIL:
+    case CellType.URL:
+    case CellType.AUTO_NUMBER:
       {
         if (value) {
           displayValue = searchValue ? _renderSearch(value, searchValue) : createColumnFormatter(type, {
@@ -443,7 +434,7 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.DURATION:
+    case CellType.DURATION:
       {
         if (value) {
           displayValue = createColumnFormatter(type, {
@@ -453,10 +444,10 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.RATE:
+    case CellType.RATE:
       {
         if (value) {
-          displayValue = /*#__PURE__*/_react.default.createElement(_RateFormatter2.default, {
+          displayValue = /*#__PURE__*/React.createElement(_RateFormatter, {
             value: value,
             column: column,
             editable: false
@@ -464,9 +455,9 @@ const getFormattedCell = function (column, row) {
         }
         break;
       }
-    case _dtableUtils.CellType.BUTTON:
+    case CellType.BUTTON:
       {
-        displayValue = /*#__PURE__*/_react.default.createElement(_ButtonFormatter2.default, {
+        displayValue = /*#__PURE__*/React.createElement(_ButtonFormatter, {
           row: row,
           column: column,
           preventClickEvent: true,
@@ -482,76 +473,108 @@ const getFormattedCell = function (column, row) {
   }
   return _getCellRecord(displayValue, rowId, column, columnWidth);
 };
-exports.getFormattedCell = getFormattedCell;
 const createColumnFormatter = (columnType, formatterProps) => {
-  const Formatter = _cellFormatterFactory.default.createFormatter(columnType);
-  if (/*#__PURE__*/_react.default.isValidElement(Formatter)) {
-    return /*#__PURE__*/_react.default.cloneElement(Formatter, {
+  const Formatter = cellFormatterFactory.createFormatter(columnType);
+  if (React.isValidElement(Formatter)) {
+    return React.cloneElement(Formatter, {
       ...formatterProps
     });
-  } else if ((0, _commonUtils.isFunction)(Formatter)) {
-    return /*#__PURE__*/_react.default.createElement(Formatter, formatterProps);
+  } else if (isFunction(Formatter)) {
+    return /*#__PURE__*/React.createElement(Formatter, formatterProps);
   }
-  return /*#__PURE__*/_react.default.createElement(_SimpleCellFormatter.default, formatterProps);
+  return /*#__PURE__*/React.createElement(SimpleCellFormatter, formatterProps);
 };
 const filterPredicateMap = {
-  [_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'
+  [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'
 };
-const USE_OPTION_ID_CELL_TYPES = [_dtableUtils.CellType.SINGLE_SELECT, _dtableUtils.CellType.MULTIPLE_SELECT];
+const USE_OPTION_ID_CELL_TYPES = [CellType.SINGLE_SELECT, CellType.MULTIPLE_SELECT];
 const getFilterByColumnTypeForPivot = (columnKey, columns, value, rows) => {
   if (!rows) rows = [];
   const filter = {
     column_key: columnKey || ''
   };
-  const column = (0, _columnUtils.getColumnByKey)(columnKey, columns);
+  const column = getColumnByKey(columnKey, columns);
   if (!column) {
     return filter;
   }
   let type = column.type;
   const columnType = column.type;
-  if (type === _dtableUtils.CellType.FORMULA) {
-    type = column.data.result_type;
+  const {
+    result_type,
+    array_type
+  } = column.data || {};
+
+  // get the actual type for formula columns
+  if (type === CellType.FORMULA) {
+    if (result_type === FORMULA_RESULT_TYPE.ARRAY && array_type) {
+      type = array_type;
+    } else {
+      type = result_type;
+    }
+  }
+  if (type === CellType.LINK_FORMULA) {
+    type = array_type;
+    // extract display_value from link formula column value
+    if (Array.isArray(value) && value.length > 0) {
+      value = value[0];
+    }
   }
-  if (type === _dtableUtils.CellType.LINK_FORMULA) {
-    type = column.data.array_type;
+
+  // handle link column based on array_type
+  if (columnType === 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) {
+      type = linkArrayType;
+    }
+    // extract display_value from link column value
+    if (Array.isArray(value) && value.length > 0 && ((_value$ = value[0]) === null || _value$ === void 0 ? void 0 : _value$.display_value) !== undefined) {
+      value = value[0].display_value;
+    }
   }
-  if (column && [_dtableUtils.CellType.GEOLOCATION, _dtableUtils.CellType.DATE, _dtableUtils.CellType.MTIME, _dtableUtils.CellType.CTIME].includes(type)) {
+  if (column && [CellType.GEOLOCATION, CellType.DATE, CellType.MTIME, CellType.CTIME].includes(type)) {
     filter['value'] = value;
     return filter;
   }
   if (typeof value === 'string') {
     value = value.trim();
   }
+
+  // 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);
   if (USE_OPTION_ID_CELL_TYPES.includes(column.type)) {
-    const options = (0, _dtableUtils.getColumnOptions)(column);
+    const options = 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);
     filter['filter_term'] = selectedOption === null || selectedOption === void 0 ? void 0 : selectedOption.id;
+  } else if (isFormulaCollaborator) {
+    filter['filter_term'] = Array.isArray(value) ? value : [value];
   } else {
     // value may contains spaces
     filter['filter_term'] = value;
   }
-
-  // link_formula use has_any_of
-  if (columnType === _dtableUtils.CellType.LINK_FORMULA) {
+  if (isFormulaCollaborator) {
+    filter['filter_predicate'] = filterPredicateMap[CellType.COLLABORATOR];
+  } else if ([CellType.LINK_FORMULA, CellType.LINK].includes(columnType)) {
     filter['filter_predicate'] = filterPredicateMap[columnType];
   } else {
     filter['filter_predicate'] = filterPredicateMap[type];
@@ -565,7 +588,7 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   };
 
   // need column to get type
-  const column = (0, _columnUtils.getColumnByKey)(columnKey, columns);
+  const column = getColumnByKey(columnKey, columns);
   if (!column) {
     return filter;
   }
@@ -574,36 +597,70 @@ const getFilterByColumnType = (columnKey, columns, rows, sqlColumnKey) => {
   let value;
   let type = column.type;
   let columnType = column.type;
+  const {
+    result_type,
+    array_type
+  } = column.data || {};
   const correctRow = rows.find(r => sqlColumnKey in r);
   value = correctRow && correctRow[sqlColumnKey];
-  if (type === _dtableUtils.CellType.FORMULA) {
-    type = column.data.result_type;
+
+  // get the actual type for formula columns
+  if (type === CellType.FORMULA) {
+    if (result_type === FORMULA_RESULT_TYPE.ARRAY && array_type) {
+      type = array_type;
+    } else {
+      type = result_type;
+    }
   }
-  if (type === _dtableUtils.CellType.LINK_FORMULA) {
-    type = column.data.array_type;
+  if (type === CellType.LINK_FORMULA) {
+    type = array_type;
+    // extract display_value from link formula column value
+    if (Array.isArray(value) && value.length > 0) {
+      value = value[0];
+    }
   }
-  if (column && [_dtableUtils.CellType.GEOLOCATION, _dtableUtils.CellType.DATE, _dtableUtils.CellType.MTIME, _dtableUtils.CellType.CTIME].includes(type)) {
+
+  // handle link column based on array_type
+  if (columnType === 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) {
+      type = linkArrayType;
+    }
+    // extract display_value from link column value
+    if (Array.isArray(value) && value.length > 0 && ((_value$2 = value[0]) === null || _value$2 === void 0 ? void 0 : _value$2.display_value) !== undefined) {
+      value = value[0].display_value;
+    }
+  }
+  if (column && [CellType.GEOLOCATION, CellType.DATE, CellType.MTIME, 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;
     return filter;
   }
 
+  // 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);
+
   // value may contains spaces
   if (typeof value === 'string') {
     value = value.trim();
   }
-  filter['filter_term'] = value;
-
-  // link_formula use has_any_of
-  if (columnType === _dtableUtils.CellType.LINK_FORMULA) {
+  if (isFormulaCollaborator) {
+    filter['filter_term'] = Array.isArray(value) ? value : [value];
+  } else {
+    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[columnType];
   } else {
     filter['filter_predicate'] = filterPredicateMap[type];
   }
   return filter;
 };
-const getFilterConditions = (statisticRecord, chart, table) => {
+export const getFilterConditions = (statisticRecord, chart, table) => {
   const columns = table.columns || [];
   const {
     name = '',
@@ -617,24 +674,32 @@ const getFilterConditions = (statisticRecord, chart, table) => {
     type
   } = config;
   const filters = [];
-  const columnKey = _constants.xAxisMap[type];
-  const groupColumnKey = _constants.groupAxisMap[type];
-  chart.config = _chartUtils.BaseUtils.convertConfig(config);
-  const chartSQLMap = (0, _sql.chartColumn2SqlColumn)(chart, table);
-  const {
+  const columnKey = xAxisMap[type];
+  const groupColumnKey = groupAxisMap[type];
+  chart.config = BaseUtils.convertConfig(config);
+  const chartSQLMap = chartColumn2SqlColumn(chart, table);
+  let {
     sqlColumnGroupbyColumnKey,
-    sqlGroupbyColumnKey
+    sqlGroupbyColumnKey,
+    sqlXColumnKey,
+    sqlYColumnKey
   } = chartSQLMap;
+  if (type === CHART_TYPE.COMPLETENESS_GROUP || type === CHART_TYPE.COMPLETENESS) {
+    const {
+      sqlColumns
+    } = chartSQLMap;
+    sqlGroupbyColumnKey = sqlColumns.name_column.key;
+  }
   if (isPivot && rows.length) {
     const xValueList = [];
     const yValueList = [];
     rows.forEach(r => {
       const xValue = r[sqlGroupbyColumnKey];
       const yValue = r[sqlColumnGroupbyColumnKey];
-      if (!xValueList.some(v => (0, _lodashEs.isEqual)(v, xValue))) {
+      if (!xValueList.some(v => isEqual(v, xValue))) {
         xValueList.push(xValue);
       }
-      if (!yValueList.some(v => (0, _lodashEs.isEqual)(v, yValue))) {
+      if (!yValueList.some(v => isEqual(v, yValue))) {
         yValueList.push(yValue);
       }
     });
@@ -648,19 +713,23 @@ const getFilterConditions = (statisticRecord, chart, table) => {
     });
   } else {
     if (name === '_Others') {
-      const columnFilters = rows.map(row => getFilterByColumnType(config[columnKey], columns, [row], sqlGroupbyColumnKey));
-      filters.push(...columnFilters);
+      const flters = rows.map(row => getFilterByColumnType(config[columnKey], columns, [row], sqlGroupbyColumnKey));
+      filters.push(...flters);
     } else {
-      let columnFilter;
       if (['map', 'map_bubble'].includes(type)) {
-        columnFilter = {
+        const filter = {
           column_key: config[columnKey],
           value: name
         };
+        filters.push(filter);
+      } else if (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);
       } else {
-        columnFilter = getFilterByColumnType(config[columnKey], columns, rows, sqlGroupbyColumnKey);
+        const filter = getFilterByColumnType(config[columnKey], columns, rows, sqlGroupbyColumnKey);
+        filters.push(filter);
       }
-      filters.push(columnFilter);
     }
     if (sqlColumnGroupbyColumnKey) {
       const groupColumnFilter = getFilterByColumnType(config[groupColumnKey], columns, rows, sqlColumnGroupbyColumnKey);
@@ -668,5 +737,4 @@ const getFilterConditions = (statisticRecord, chart, table) => {
     }
   }
   return filters;
-};
-exports.getFilterConditions = getFilterConditions;
+};