@seafile/sdoc-editor 1.0.31 → 1.0.33

package/dist/basic-sdk/assets/css/dropdown-menu.css

@@ -3,6 +3,11 @@
   min-width: 12rem;
 }
 
+.sdoc-dropdown-menu .sdoc-seatable-selected-table-list-wrapper {
+  max-height: 300px;
+  overflow: auto;
+}
+
 .sdoc-dropdown-menu .sdoc-dropdown-menu-divider {
   width: 100%;
   height: 0;

package/dist/basic-sdk/extension/plugins/seatable-column/helpers.js

@@ -2,6 +2,7 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { Editor, Transforms, Range } from '@seafile/slate';
 import slugid from 'slugid';
 import { BLOCKQUOTE, CHECK_LIST_ITEM, COLUMN, IMAGE, ORDERED_LIST, PARAGRAPH, TABLE_CELL, UNORDERED_LIST } from '../../constants/element-type';
+import { INSERT_POSITION } from '../../constants';
 import { focusEditor, getNodeType } from '../../core';
 import Column from './model';
 import * as CellType from './constants/cell-types';
@@ -46,10 +47,19 @@ export const getColumnType = editor => {
   const [n] = match;
   return getNodeType(n);
 };
-export const insertSeaTableColumn = (editor, active, option) => {
+export const insertSeaTableColumn = function (editor, active, option) {
+  let insertPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : INSERT_POSITION.CURRENT;
   if (!active) {
     const column = new Column(option);
     column.id = slugid.nice();
+    if (insertPosition === INSERT_POSITION.AFTER) {
+      const path = Editor.path(editor, editor.selection);
+      path && Transforms.insertNodes(editor, _objectSpread({}, column), {
+        at: [path[0] + 1]
+      });
+      focusEditor(editor);
+      return;
+    }
     Transforms.insertNodes(editor, _objectSpread({}, column));
   }
   focusEditor(editor);

package/dist/basic-sdk/extension/plugins/seatable-column/menu/column-list-menu.css

@@ -8,7 +8,7 @@
     background-color: #fff;
     min-width: 12rem;
     width: 200px;
-    max-height: 400px;
+    max-height: 300px;
     overflow: auto;
     padding: 8px 0;
 }

package/dist/basic-sdk/extension/plugins/seatable-column/menu/column-list-menu.js

@@ -6,8 +6,10 @@ import './column-list-menu.css';
 const NOT_SUPPORT_COLUMN_TYPES = ['button', 'file'];
 export default function ColumnListMenu(_ref) {
   let {
-    editor
+    editor,
+    insertPosition
   } = _ref;
+  const computedBottom = insertPosition ? '0px' : '';
   const columns = useMemo(() => {
     if (!editor.columns) return [];
     return editor.columns.filter(column => !NOT_SUPPORT_COLUMN_TYPES.includes(column.type));
@@ -27,10 +29,13 @@ export default function ColumnListMenu(_ref) {
   };
   const onMousedown = useCallback(option => {
     const active = isActive(editor);
-    insertSeaTableColumn(editor, active, option);
-  }, [editor]);
+    insertSeaTableColumn(editor, active, option, insertPosition);
+  }, [editor, insertPosition]);
   return /*#__PURE__*/React.createElement("div", {
-    className: "column-list-menu"
+    className: "column-list-menu",
+    style: {
+      bottom: computedBottom
+    }
   }, options.map(option => {
     return /*#__PURE__*/React.createElement("div", {
       key: option.value,

package/dist/basic-sdk/extension/plugins/seatable-column/menu/index.js

@@ -7,7 +7,8 @@ import { isMenuDisabled } from '../helpers';
 const SeaTableColumnMenu = _ref => {
   let {
     editor,
-    readonly
+    readonly,
+    insertPosition
   } = _ref;
   const disabled = isMenuDisabled(editor, readonly);
   const menuConfig = MENUS_CONFIG_MAP[ELEMENT_TYPE.COLUMN];
@@ -17,16 +18,17 @@ const SeaTableColumnMenu = _ref => {
     className: "pr-2"
   }, !disabled && /*#__PURE__*/React.createElement("i", {
     className: "sdocfont sdoc-right-slide sdoc-dropdown-item-right-icon"
-  })), !disabled && /*#__PURE__*/React.createElement(UncontrolledPopover, {
+  }), !disabled && /*#__PURE__*/React.createElement(UncontrolledPopover, {
     target: menuConfig.id,
-    className: "sdoc-menu-popover sdoc-dropdown-menu sdoc-sub-dropdown-menu",
     trigger: "hover",
     placement: "right-start",
     hideArrow: true,
-    fade: false
+    fade: false,
+    popperClassName: "seatable-column-popover"
   }, /*#__PURE__*/React.createElement(ColumnListMenu, {
     editor: editor,
-    readonly: readonly
-  })));
+    readonly: readonly,
+    insertPosition: insertPosition
+  }))));
 };
 export default SeaTableColumnMenu;

package/dist/basic-sdk/extension/plugins/seatable-tables/formatter/collaborator-wrapper.js

@@ -0,0 +1,101 @@
+import _CreatorFormatter from "dtable-ui-component/lib/CreatorFormatter";
+import _CollaboratorFormatter from "dtable-ui-component/lib/CollaboratorFormatter";
+import _Loading from "dtable-ui-component/lib/Loading";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import React from 'react';
+import EventBus from '../../../../utils/event-bus';
+import { EXTERNAL_EVENT } from '../../../../../constants';
+function withCollaborators(Component) {
+  return class Wrapper extends React.Component {
+    constructor(props) {
+      super(props);
+      _defineProperty(this, "getFormattedCellValue", () => {
+        const {
+          value
+        } = this.props;
+        if (!value || Array.isArray(value) && value.length === 0) {
+          return null;
+        }
+        const isSingleValue = value && !Array.isArray(value);
+        const formattedCellValue = isSingleValue ? [value] : value;
+        return formattedCellValue;
+      });
+      _defineProperty(this, "onCollaboratorsChanged", emailUserMap => {
+        const {
+          isLoading
+        } = this.state;
+        if (!isLoading) return;
+        const cellValue = this.getFormattedCellValue();
+        if (!cellValue) {
+          this.setState({
+            isLoading: false,
+            collaborators: []
+          });
+          // this.unsubscribeUsersChanged();
+          return;
+        }
+        const collaborators = cellValue.map(email => emailUserMap[email]).filter(Boolean);
+        if (collaborators.length === cellValue.length) {
+          this.setState({
+            isLoading: false,
+            collaborators: collaborators
+          });
+          // this.unsubscribeUsersChanged();
+          return;
+        }
+
+        // nothing todo
+      });
+      this.state = {
+        isLoading: true,
+        collaborators: []
+      };
+    }
+    async componentDidMount() {
+      // TODO: Cheating, non-compliant operations
+      const {
+        collaboratorManager
+      } = window.seafile || window.seafileConfig;
+      const cellValue = this.getFormattedCellValue();
+      if (!cellValue) {
+        this.setState({
+          isLoading: false,
+          collaborators: []
+        });
+        return;
+      }
+      const emailUserMap = await collaboratorManager.getEmailUserMap(cellValue);
+      if (emailUserMap) {
+        const collaborators = cellValue.map(email => emailUserMap[email]);
+        this.setState({
+          isLoading: false,
+          collaborators: collaborators
+        });
+        return;
+      }
+      const eventBus = EventBus.getInstance();
+      this.unsubscribeUsersChanged = eventBus.subscribe(EXTERNAL_EVENT.COLLABORATORS_UPDATED, this.onCollaboratorsChanged);
+    }
+    render() {
+      const {
+        isLoading,
+        collaborators
+      } = this.state;
+      if (isLoading) {
+        return /*#__PURE__*/React.createElement(_Loading, null);
+      }
+      const {
+        value,
+        containerClassName
+      } = this.props;
+      return /*#__PURE__*/React.createElement(Component, {
+        collaborators: collaborators,
+        value: value,
+        containerClassName: containerClassName
+      });
+    }
+  };
+}
+const CustomCollaboratorFormatter = withCollaborators(_CollaboratorFormatter);
+const CustomCreatorFormatter = withCollaborators(_CreatorFormatter);
+export { CustomCollaboratorFormatter, CustomCreatorFormatter };

package/dist/basic-sdk/extension/plugins/seatable-tables/formatter/index.js

@@ -6,7 +6,6 @@ import _EmailFormatter from "dtable-ui-component/lib/EmailFormatter";
 import _UrlFormatter from "dtable-ui-component/lib/UrlFormatter";
 import _AutoNumberFormatter from "dtable-ui-component/lib/AutoNumberFormatter";
 import _FormulaFormatter from "dtable-ui-component/lib/FormulaFormatter";
-import _CreatorFormatter from "dtable-ui-component/lib/CreatorFormatter";
 import _MTimeFormatter from "dtable-ui-component/lib/MTimeFormatter";
 import _CTimeFormatter from "dtable-ui-component/lib/CTimeFormatter";
 import _CheckboxFormatter from "dtable-ui-component/lib/CheckboxFormatter";
@@ -18,12 +17,13 @@ import _GeolocationFormatter from "dtable-ui-component/lib/GeolocationFormatter"
 import _FileFormatter from "dtable-ui-component/lib/FileFormatter";
 import _ImageFormatter from "dtable-ui-component/lib/ImageFormatter";
 import _SimpleLongTextFormatter from "dtable-ui-component/lib/SimpleLongTextFormatter";
-import _CollaboratorFormatter from "dtable-ui-component/lib/CollaboratorFormatter";
 import _TextFormatter from "dtable-ui-component/lib/TextFormatter";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import React, { Fragment } from 'react';
 import { CellType, SELECT_OPTION_COLORS } from 'dtable-utils';
 import { withTranslation } from 'react-i18next';
+import { CustomCollaboratorFormatter, CustomCreatorFormatter } from './collaborator-wrapper';
+import LinkFormatter from './link-formatter';
 class CellFormatter extends React.Component {
   constructor() {
     super(...arguments);
@@ -64,13 +64,11 @@ class CellFormatter extends React.Component {
           }
         case CellType.COLLABORATOR:
           {
-            // TODO
             if (!Array.isArray(cellValue) || cellValue.length === 0) return this.renderEmptyFormatter();
             cellValue = cellValue.filter(item => item);
             if (cellValue.length === 0) return this.renderEmptyFormatter();
-            return /*#__PURE__*/React.createElement(_CollaboratorFormatter, {
+            return /*#__PURE__*/React.createElement(CustomCollaboratorFormatter, {
               value: cellValue,
-              collaborators: collaborators,
               containerClassName: containerClassName
             });
           }
@@ -173,12 +171,10 @@ class CellFormatter extends React.Component {
         case CellType.CREATOR:
         case CellType.LAST_MODIFIER:
           {
-            // TODO
-            return /*#__PURE__*/React.createElement(_CreatorFormatter, {
+            if (cellValue.length === 0) return this.renderEmptyFormatter();
+            return /*#__PURE__*/React.createElement(CustomCreatorFormatter, {
               value: cellValue,
-              collaborators: collaborators,
-              containerClassName: containerClassName,
-              renderEmptyFormatter: this.renderEmptyFormatter
+              containerClassName: containerClassName
             });
           }
         case CellType.FORMULA:
@@ -194,8 +190,15 @@ class CellFormatter extends React.Component {
           }
         case CellType.LINK:
           {
-            // TODO
-            return null;
+            if (!Array.isArray(cellValue) || cellValue.length === 0) return this.renderEmptyFormatter();
+            return /*#__PURE__*/React.createElement(LinkFormatter, {
+              value: cellValue,
+              column: column,
+              collaborators: collaborators,
+              containerClassName: containerClassName,
+              renderEmptyFormatter: this.renderEmptyFormatter,
+              t: this.props.t
+            });
           }
         case CellType.AUTO_NUMBER:
           {

package/dist/basic-sdk/extension/plugins/seatable-tables/formatter/link-formatter/index.css

@@ -0,0 +1,41 @@
+/* link */
+.seatable-view-body-column-cell .document-link-formatter {
+  display: flex;
+  align-items: center;
+  overflow: hidden;
+  flex-wrap: nowrap;
+  width: 100%;
+  height: 100%;
+}
+
+.seatable-view-body-column-cell .document-link-formatter .document-link-item {
+  flex-shrink: 0;
+  height: 20px;
+  margin-right: 4px;
+  padding: 0 6px;
+  font-size: 13px;
+  max-width: 100%;
+  background: #eceff4;
+  border-radius: 3px;
+  align-items: center;
+  vertical-align: middle;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  line-height: 20px;
+  width: fit-content;
+}
+
+.seatable-view-body-column-cell .document-link-formatter .document-checkbox-item {
+  width: fit-content;
+  margin-right: 10px;
+  line-height: 36px;
+}
+
+.seatable-view-body-column-cell .document-link-formatter .document-long-text-item {
+  display: inline-flex;
+  margin-right: 10px;
+  font-size: 13px;
+  max-width: 100%;
+  flex-shrink: 0;
+}

package/dist/basic-sdk/extension/plugins/seatable-tables/formatter/link-formatter/index.js

@@ -0,0 +1,275 @@
+import _DepartmentSingleSelectFormatter from "dtable-ui-component/lib/DepartmentSingleSelectFormatter";
+import _LongTextFormatter from "dtable-ui-component/lib/LongTextFormatter";
+import _CheckboxFormatter from "dtable-ui-component/lib/CheckboxFormatter";
+import _MultipleSelectFormatter from "dtable-ui-component/lib/MultipleSelectFormatter";
+import _MTimeFormatter from "dtable-ui-component/lib/MTimeFormatter";
+import _CTimeFormatter from "dtable-ui-component/lib/CTimeFormatter";
+import _DateFormatter from "dtable-ui-component/lib/DateFormatter";
+import _NumberFormatter from "dtable-ui-component/lib/NumberFormatter";
+import React from 'react';
+import { CellType, FORMULA_RESULT_TYPE, getDurationDisplayString, getGeolocationDisplayString, getMultipleOptionName } from 'dtable-utils';
+import { CustomCreatorFormatter } from '../collaborator-wrapper';
+import { getCellDisplayValue, getFormulaArrayValue, isArrayFormalColumn } from './utils';
+function LinkFormatter(props) {
+  const {
+    column,
+    value,
+    containerClassName,
+    collaborators
+  } = props;
+  const {
+    data
+  } = column;
+  if (!Array.isArray(value) || value.length === 0) return props.renderEmptyFormatter();
+  let {
+    display_column: displayColumn
+  } = data || {};
+  if (!displayColumn) return props.renderEmptyFormatter();
+  const {
+    type: displayColumnType,
+    data: displayColumnData
+  } = displayColumn;
+  const cellValue = getFormulaArrayValue(value, !isArrayFormalColumn(displayColumnType));
+  if (!Array.isArray(cellValue) || cellValue.length === 0) return props.renderEmptyFormatter();
+  switch (displayColumnType) {
+    case CellType.TEXT:
+    case CellType.AUTO_NUMBER:
+    case CellType.EMAIL:
+    case CellType.URL:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, value);
+        }));
+      }
+    case CellType.NUMBER:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value && value !== 0) return null;
+          return /*#__PURE__*/React.createElement(_NumberFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            containerClassName: "document-link-item",
+            data: displayColumnData || {},
+            value: value
+          });
+        }));
+      }
+    case CellType.DATE:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value || typeof value !== 'string') return null;
+          const {
+            format
+          } = displayColumnData || {};
+          return /*#__PURE__*/React.createElement(_DateFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            value: value,
+            format: format,
+            containerClassName: "document-link-item"
+          });
+        }));
+      }
+    case CellType.CTIME:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement(_CTimeFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            value: value,
+            containerClassName: "document-link-item"
+          });
+        }));
+      }
+    case CellType.MTIME:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement(_MTimeFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            value: value,
+            containerClassName: "document-link-item"
+          });
+        }));
+      }
+    case CellType.DURATION:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, getDurationDisplayString(value, displayColumnData));
+        }));
+      }
+    case CellType.CREATOR:
+    case CellType.LAST_MODIFIER:
+      {
+        return /*#__PURE__*/React.createElement(CustomCreatorFormatter, {
+          value: cellValue
+        });
+      }
+    case CellType.SINGLE_SELECT:
+      {
+        if (!cellValue || cellValue.length === 0) {
+          return props.renderEmptyFormatter();
+        }
+        const options = displayColumnData && Array.isArray(displayColumnData.options) ? displayColumnData.options : [];
+        return /*#__PURE__*/React.createElement(_MultipleSelectFormatter, {
+          value: cellValue,
+          options: options || [],
+          containerClassName: "dtable-dataset-".concat(displayColumnType, "-formatter")
+        });
+      }
+    case CellType.MULTIPLE_SELECT:
+      {
+        if (!cellValue || cellValue.length === 0) {
+          return props.renderEmptyFormatter();
+        }
+        const options = displayColumnData && Array.isArray(displayColumnData.options) ? displayColumnData.options : [];
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          const valueDisplayString = Array.isArray(value) ? getMultipleOptionName(options, value) : getMultipleOptionName(options, [value]);
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, valueDisplayString);
+        }));
+      }
+    case CellType.COLLABORATOR:
+      {
+        if (!cellValue || cellValue.length === 0) {
+          return props.renderEmptyFormatter();
+        }
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          const valueDisplayString = Array.isArray(value) ? getCellDisplayValue({
+            [displayColumn.key]: value
+          }, displayColumn, collaborators) : getCellDisplayValue({
+            [displayColumn.key]: [value]
+          }, displayColumn, collaborators);
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, valueDisplayString);
+        }));
+      }
+    case CellType.CHECKBOX:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          return /*#__PURE__*/React.createElement(_CheckboxFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            value: Boolean(value),
+            containerClassName: "document-".concat(displayColumnType, "-item")
+          });
+        }));
+      }
+    case CellType.GEOLOCATION:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, getGeolocationDisplayString(value, displayColumnData, {
+            hyphen: ' '
+          }));
+        }));
+      }
+    case CellType.LONG_TEXT:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement(_LongTextFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            value: value,
+            containerClassName: "document-".concat(displayColumnType, "-item")
+          });
+        }));
+      }
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, getCellDisplayValue({
+            [displayColumn.key]: value
+          }, displayColumn, collaborators));
+        }));
+      }
+    case FORMULA_RESULT_TYPE.BOOL:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, value + '');
+        }));
+      }
+    case FORMULA_RESULT_TYPE.STRING:
+      {
+        return /*#__PURE__*/React.createElement("div", {
+          className: containerClassName
+        }, cellValue.map((value, index) => {
+          if (!value) return null;
+          return /*#__PURE__*/React.createElement("div", {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            className: "document-link-item"
+          }, value);
+        }));
+      }
+    case CellType.DEPARTMENT_SINGLE_SELECT:
+      {
+        const {
+          userId,
+          departments = []
+        } = window.seafile || window.seafileConfig;
+        if (!userId) return null;
+        return cellValue.map((item, index) => {
+          return /*#__PURE__*/React.createElement(_DepartmentSingleSelectFormatter, {
+            key: "link-".concat(displayColumnType, "-").concat(index),
+            tip: props.t('Deleted_department'),
+            value: item,
+            departments: departments,
+            containerClassName: containerClassName
+          });
+        });
+      }
+    default:
+      {
+        return props.renderEmptyFormatter();
+      }
+  }
+}
+export default LinkFormatter;

package/dist/basic-sdk/extension/plugins/seatable-tables/formatter/link-formatter/utils.js

@@ -0,0 +1,73 @@
+import { CellType, getCellValueDisplayString } from 'dtable-utils';
+export const isValidCellValue = value => {
+  if (value === undefined) return false;
+  if (value === null) return false;
+  if (value === '') return false;
+  if (JSON.stringify(value) === '{}') return false;
+  if (JSON.stringify(value) === '[]') return false;
+  return true;
+};
+export const getCellDisplayValue = (record, column, collaborators) => {
+  const {
+    type,
+    data,
+    key
+  } = column;
+  return getCellValueDisplayString(record, type, key, {
+    data,
+    collaborators,
+    geolocationHyphen: ' '
+  });
+};
+export const getTwoDimensionArrayValue = value => {
+  if (!Array.isArray(value)) return [];
+  return value.map(item => {
+    if (Object.prototype.toString.call(item) !== '[object Object]') {
+      return item;
+    }
+    if (!Object.prototype.hasOwnProperty.call(item, 'display_value')) return item;
+    const {
+      display_value
+    } = item;
+    if (!Array.isArray(display_value) || display_value.length === 0) return display_value;
+    return display_value.map(i => {
+      if (Object.prototype.toString.call(i) === '[object Object]') {
+        if (!Object.prototype.hasOwnProperty.call(i, 'display_value')) return i;
+        const {
+          display_value
+        } = i;
+        return display_value;
+      }
+      return i;
+    });
+  });
+};
+export const getFormulaArrayValue = function (value) {
+  let isFlat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!Array.isArray(value)) return [];
+  if (!isFlat) return getTwoDimensionArrayValue(value);
+  return value.map(item => {
+    if (Object.prototype.toString.call(item) !== '[object Object]') {
+      return item;
+    }
+    if (!Object.prototype.hasOwnProperty.call(item, 'display_value')) return item;
+    const {
+      display_value
+    } = item;
+    if (!Array.isArray(display_value) || display_value.length === 0) return display_value;
+    return display_value.map(i => {
+      if (Object.prototype.toString.call(i) === '[object Object]') {
+        if (!Object.prototype.hasOwnProperty.call(i, 'display_value')) return i;
+        const {
+          display_value
+        } = i;
+        return display_value;
+      }
+      return i;
+    });
+  }).flat().filter(item => isValidCellValue(item));
+};
+export function isArrayFormalColumn(columnType) {
+  const multipleValueTypes = [CellType.IMAGE, CellType.FILE, CellType.MULTIPLE_SELECT, CellType.COLLABORATOR];
+  return multipleValueTypes.includes(columnType);
+}