@seafile/sdoc-editor 1.0.17 → 1.0.18

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filter-popover.js

@@ -0,0 +1,200 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import React, { Component } from 'react';
+import isHotkey from 'is-hotkey';
+import { Button, UncontrolledPopover } from 'reactstrap';
+import { withTranslation } from 'react-i18next';
+import { FILTER_COLUMN_OPTIONS, getValidFilters } from 'dtable-utils';
+import CommonAddTool from '../common-add-tool';
+import { getEventClassName } from '../utils/utils';
+import FiltersList from './filter-popover-widgets/filters-list';
+import { getFilterByColumn } from './filters-utils';
+import './filter-popover.css';
+
+/**
+ * filter = {
+ *  column_key: '',
+ *  filter_predicate: '',
+ *  filter_term: '',
+ *  filter_term_modifier: '',
+ * }
+ */
+class FilterPopover extends Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "onHotKey", e => {
+      if (isHotkey('esc', e)) {
+        e.preventDefault();
+        this.props.hidePopover();
+      }
+    });
+    _defineProperty(this, "hideDTablePopover", e => {
+      if (this.dtablePopoverRef && !getEventClassName(e).includes('popover') && !this.dtablePopoverRef.contains(e.target)) {
+        this.props.hidePopover(e);
+        e.preventDefault();
+        e.stopPropagation();
+        return false;
+      }
+    });
+    _defineProperty(this, "isNeedSubmit", () => {
+      return this.props.isNeedSubmit;
+    });
+    _defineProperty(this, "update", filters => {
+      if (this.isNeedSubmit()) {
+        const isSubmitDisabled = false;
+        this.setState({
+          filters,
+          isSubmitDisabled
+        });
+        return;
+      }
+      this.setState({
+        filters
+      }, () => {
+        const update = {
+          filters,
+          filter_conjunction: this.state.filterConjunction
+        };
+        this.props.update(update);
+      });
+    });
+    _defineProperty(this, "deleteFilter", (filterIndex, scheduleUpdate) => {
+      const filters = this.state.filters.slice(0);
+      filters.splice(filterIndex, 1);
+      if (filters.length === 0) {
+        scheduleUpdate();
+      }
+      this.update(filters);
+    });
+    _defineProperty(this, "updateFilter", (filterIndex, updated) => {
+      const filters = this.state.filters.slice(0);
+      filters[filterIndex] = updated;
+      this.update(filters);
+    });
+    _defineProperty(this, "updateFilterConjunction", conjunction => {
+      if (this.isNeedSubmit()) {
+        const isSubmitDisabled = false;
+        this.setState({
+          filterConjunction: conjunction,
+          isSubmitDisabled
+        });
+        return;
+      }
+      this.setState({
+        filterConjunction: conjunction
+      }, () => {
+        const update = {
+          filters: this.state.filters,
+          filter_conjunction: conjunction
+        };
+        this.props.update(update);
+      });
+    });
+    _defineProperty(this, "addFilter", scheduleUpdate => {
+      let {
+        columns
+      } = this.props;
+      let defaultColumn = columns[0];
+      if (!FILTER_COLUMN_OPTIONS[defaultColumn.type]) {
+        defaultColumn = columns.find(c => FILTER_COLUMN_OPTIONS[c.type]);
+      }
+      if (!defaultColumn) return;
+      let filter = getFilterByColumn(defaultColumn);
+      const filters = this.state.filters.slice(0);
+      if (filters.length === 0) {
+        scheduleUpdate();
+      }
+      filters.push(filter);
+      this.update(filters);
+    });
+    _defineProperty(this, "onClosePopover", () => {
+      this.props.hidePopover();
+    });
+    _defineProperty(this, "onSubmitFilters", () => {
+      const {
+        filters,
+        filterConjunction
+      } = this.state;
+      const update = {
+        filters,
+        filter_conjunction: filterConjunction
+      };
+      this.props.update(update);
+      this.props.hidePopover();
+    });
+    _defineProperty(this, "onPopoverInsideClick", e => {
+      e.stopPropagation();
+    });
+    this.state = {
+      filters: getValidFilters(props.filters, props.columns),
+      filterConjunction: props.filterConjunction || 'And'
+    };
+  }
+  componentDidMount() {
+    document.addEventListener('mousedown', this.hideDTablePopover, true);
+    document.addEventListener('keydown', this.onHotKey);
+  }
+  componentWillUnmount() {
+    document.removeEventListener('mousedown', this.hideDTablePopover, true);
+    document.removeEventListener('keydown', this.onHotKey);
+  }
+  render() {
+    const {
+      target,
+      columns,
+      t
+    } = this.props;
+    const {
+      filters,
+      filterConjunction
+    } = this.state;
+    const canAddFilter = columns.length > 0;
+    return /*#__PURE__*/React.createElement(UncontrolledPopover, {
+      placement: "auto-start",
+      isOpen: true,
+      target: target,
+      fade: false,
+      hideArrow: true,
+      className: "filter-popover",
+      boundariesElement: document.body
+    }, _ref => {
+      let {
+        scheduleUpdate
+      } = _ref;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: ref => this.dtablePopoverRef = ref,
+        onClick: this.onPopoverInsideClick,
+        className: this.props.filtersClassName
+      }, /*#__PURE__*/React.createElement(FiltersList, {
+        filterConjunction: filterConjunction,
+        filters: filters,
+        columns: columns,
+        emptyPlaceholder: t('No_filters'),
+        updateFilter: this.updateFilter,
+        deleteFilter: this.deleteFilter,
+        updateFilterConjunction: this.updateFilterConjunction,
+        collaborators: this.props.collaborators,
+        readOnly: false,
+        scheduleUpdate: scheduleUpdate,
+        isPre: this.props.isPre
+      }), /*#__PURE__*/React.createElement(CommonAddTool, {
+        className: "popover-add-tool ".concat(canAddFilter ? '' : 'disabled'),
+        callBack: canAddFilter ? () => this.addFilter(scheduleUpdate) : () => {},
+        footerName: t('Add_filter'),
+        addIconClassName: "popover-add-icon"
+      }), this.isNeedSubmit() && /*#__PURE__*/React.createElement("div", {
+        className: "filter-popover-footer"
+      }, /*#__PURE__*/React.createElement(Button, {
+        className: "mr-2",
+        onClick: this.onClosePopover
+      }, t('Cancel')), /*#__PURE__*/React.createElement(Button, {
+        color: "primary",
+        disabled: this.state.isSubmitDisabled,
+        onClick: this.onSubmitFilters
+      }, t('Submit'))));
+    });
+  }
+}
+_defineProperty(FilterPopover, "defaultProps", {
+  filtersClassName: ''
+});
+export default withTranslation('sdoc-editor')(FilterPopover);

package/dist/basic-sdk/extension/plugins/seatable-tables/seatable-settings/filter-setter/filters-utils.js

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