@seafile/sdoc-editor 0.3.25 → 0.3.26-2

package/dist/basic-sdk/extension/plugins/chart/chart-components/data-filter-setting/filters-popover.css

@@ -0,0 +1,30 @@
+.filter-popover .popover {
+  max-width: none;
+  min-width: 300px;
+}
+
+.filter-popover .popover-add-tool {
+  border-top: none;
+  color: #555555;
+}
+
+.filter-popover .popover-add-tool.disabled {
+  color: #c2c2c2;
+}
+
+.filter-popover .popover-add-tool.disabled:hover {
+  cursor: not-allowed;
+  background: #fff;
+}
+
+.filter-popover .popover-add-tool .popover-add-icon {
+  margin-right: 14px;
+}
+
+.filter-popover .filter-popover-footer {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  padding: 1rem;
+  border-top: 1px solid #e9ecef;
+}

package/dist/basic-sdk/extension/plugins/chart/chart-components/data-filter-setting/index.css

@@ -0,0 +1,18 @@
+.seatable-app-custom-edit-page .app-custom-page-statistic-data-filter {
+	width: 100%;
+	padding: 3px 4px;
+	border-radius: 4px;
+	line-height: 22px;
+}
+
+.seatable-app-custom-edit-page .app-custom-page-statistic-data-filter:hover {
+	cursor: pointer;
+	background-color: #efefef;
+}
+
+.seatable-app-custom-edit-page .app-custom-page-statistic-data-filter .dtable-icon-filter {
+	font-size: 14px;
+	color: #666;
+	margin-right: 10px;
+}
+  

package/dist/basic-sdk/extension/plugins/chart/chart-components/data-filter-setting/index.js

@@ -0,0 +1,79 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import React, { Component } from 'react';
+import { withTranslation } from 'react-i18next';
+import { Label, FormGroup } from 'reactstrap';
+import MediaQuery from 'react-responsive';
+import FilterPopover from './filter-popover';
+import { eventStopPropagation } from '../../../../../utils/mouse-event';
+import context from '../../../../../../context';
+import './index.css';
+class DataFilter extends Component {
+  constructor(props) {
+    super(props);
+    this.toggleFilterPopover = event => {
+      eventStopPropagation(event);
+      this.setState({
+        isFilterSetterShow: !this.state.isFilterSetterShow
+      });
+    };
+    this.updateFilters = update => {
+      const {
+        statItem
+      } = this.props;
+      this.props.updateSetting({
+        config: _objectSpread(_objectSpread({}, statItem), update)
+      });
+    };
+    this.state = {
+      isFilterSetterShow: false
+    };
+  }
+  render() {
+    const {
+      tables,
+      t,
+      statItem
+    } = this.props;
+    const {
+      filters,
+      filter_conjunction,
+      table_id
+    } = statItem;
+    const selectedTable = tables.find(item => item.id === table_id);
+    const collaborators = [];
+    // const collaborators = context.getCollaboratorsFromCache();
+    let filterMessage = t('Filter');
+    if (filters.length === 1) {
+      filterMessage = t('1 Filter');
+    } else if (filters.length > 1) {
+      filterMessage = filters.length + ' ' + t('Filters');
+    }
+    return /*#__PURE__*/React.createElement(FormGroup, {
+      className: "statistics-parameter-item"
+    }, /*#__PURE__*/React.createElement(Label, null, t('Data_settings')), selectedTable ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      id: "app-custom-page-statistic-data-filter",
+      className: "app-custom-page-statistic-data-filter",
+      onClick: this.toggleFilterPopover
+    }, /*#__PURE__*/React.createElement("i", {
+      className: "dtable-font dtable-icon-filter"
+    }), /*#__PURE__*/React.createElement("span", null, filterMessage)), this.state.isFilterSetterShow && /*#__PURE__*/React.createElement(MediaQuery, {
+      query: "(min-width: 767.8px)"
+    }, /*#__PURE__*/React.createElement(FilterPopover, {
+      isNeedSubmit: true,
+      isPre: true,
+      target: "app-custom-page-statistic-data-filter",
+      filters: filters,
+      filterConjunction: filter_conjunction,
+      columns: selectedTable.columns,
+      collaborators: collaborators,
+      hidePopover: this.toggleFilterPopover,
+      update: this.updateFilters
+    }))) : /*#__PURE__*/React.createElement("div", {
+      id: "app-custom-page-statistic-data-filter",
+      className: "app-custom-page-statistic-data-filter disabled"
+    }, /*#__PURE__*/React.createElement("i", {
+      className: "dtable-font dtable-icon-filter"
+    }), /*#__PURE__*/React.createElement("span", null, filterMessage)));
+  }
+}
+export default withTranslation('sdoc-editor')(DataFilter);

package/dist/basic-sdk/extension/plugins/chart/chart-components/data-filter-setting/utils.js

@@ -0,0 +1,531 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+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, DEFAULT_DATE_FORMAT } from 'dtable-utils';
+import context from '../../../../../../context';
+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];
+export const getEventClassName = e => {
+  // svg mouseEvent event.target.className is an object
+  if (!e || !e.target) return '';
+  return e.target.getAttribute('class') || '';
+};
+export const isFunction = functionToCheck => {
+  const getType = {};
+  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
+};
+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 function getColumnByKey(columnKey, columns) {
+  if (!columnKey || !Array.isArray(columns)) {
+    return null;
+  }
+  return columns.find(column => column.key === columnKey);
+}
+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;
+};
+export const getNormalizedDepartments = function (departments) {
+  let canExpand = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let parentIdMap = {};
+  for (let i = 0; i < departments.length; i++) {
+    let item = departments[i];
+    parentIdMap[item.parent_id] = true;
+  }
+  return departments.map(depart => {
+    const hasChild = canExpand && !!parentIdMap[depart.id];
+    const isExpanded = depart.parent_id === -1 ? true : false;
+    return _objectSpread(_objectSpread({}, depart), {}, {
+      hasChild,
+      isExpanded
+    });
+  });
+};
+export const searchDepartments = (departments, searchValue) => {
+  const validSearchValue = searchValue ? searchValue.trim().toLowerCase() : '';
+  const validDepartments = Array.isArray(departments) ? departments : [];
+  if (!validSearchValue) return validDepartments;
+  return validDepartments.filter(department => {
+    const {
+      name
+    } = department;
+    if (!name) return false;
+    return name.toString().toLowerCase().indexOf(validSearchValue) > -1;
+  });
+};
+export function getDateColumnFormat(column) {
+  const format = column && column.data && column.data.format ? column.data.format : DEFAULT_DATE_FORMAT;
+  // Old Europe format is D/M/YYYY new format is DD/MM/YYYY
+  return format;
+}
+export function isCheckboxColumn(column) {
+  let {
+    type,
+    data
+  } = column;
+  if (FORMULA_COLUMN_TYPES_MAP[type]) {
+    const {
+      result_type,
+      array_type
+    } = data || {};
+    if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+      return array_type === CellType.CHECKBOX;
+    }
+    return false;
+  }
+  return type === CellType.CHECKBOX;
+}
+export const generateDefaultUser = name => {
+  const mediaUrl = context.getSetting('mediaUrl');
+  const defaultAvatarUrl = "".concat(mediaUrl, "avatars/default.png");
+  return {
+    name,
+    email: name,
+    avatar_url: defaultAvatarUrl
+  };
+};

package/dist/basic-sdk/extension/plugins/chart/chart-components/seatable-radio/index.js

@@ -0,0 +1,28 @@
+import React from 'react';
+import classnames from 'classnames';
+import './style.css';
+function SeaTableRadio(props) {
+  return /*#__PURE__*/React.createElement("label", {
+    className: "seatable-radio"
+  }, /*#__PURE__*/React.createElement("input", {
+    type: "radio",
+    className: "seatable-radio-input",
+    checked: props.isChecked,
+    onChange: props.disabled ? () => {} : props.onCheckedChange,
+    name: props.name,
+    value: props.value
+  }), /*#__PURE__*/React.createElement("span", {
+    className: classnames('seatable-radio-indicator', {
+      'seatable-radio-selected-indicator': props.isChecked,
+      'seatable-radio-disable': props.disabled
+    })
+  }), /*#__PURE__*/React.createElement("span", {
+    className: "seatable-radio-description text-truncate"
+  }, props.label));
+}
+SeaTableRadio.defaultProps = {
+  disabled: false,
+  name: 'seatable-radio-input',
+  onCheckedChange: () => {}
+};
+export default SeaTableRadio;