@seafile/sdoc-editor 0.3.25 → 0.3.26-2

package/dist/basic-sdk/extension/plugins/chart/chart-utils/common-utils/base-utils.js

@@ -0,0 +1,430 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { CellType, FORMULA_RESULT_TYPE, sortText, sortNumber, sortDate, sortSingleSelect, getFormulaDisplayString, getNumberDisplayString } from 'dtable-utils';
+import { FORMULA_COLUMN_TYPES, COLLABORATOR_COLUMN_TYPES } from '../../constants/special-column-types';
+import { DEFAULT_LABEL_FONT_SIZE, STATISTICS_COUNT_TYPE, STAT_TYPE } from '../../constants';
+const Y_AXIS_SUPPORT_ROW_COUNT_CHARTS = [STAT_TYPE.BASIC_NUMBER_CARD];
+const SUPPORT_SORT_COLUMNS = [CellType.TEXT, CellType.NUMBER, CellType.DATE, CellType.SINGLE_SELECT, CellType.FORMULA, CellType.LINK_FORMULA, CellType.CTIME, CellType.MTIME, CellType.RATE];
+export const isNumber = num => {
+  return (num || num === 0) && Object.prototype.toString.call(num) === '[object Number]';
+};
+export function isEmptyGeolocationCell(value, format) {
+  if (!value) return null;
+  if (format === 'lng_lat') {
+    return value.lng && value.lat;
+  }
+  if (format === 'country_region') {
+    return value.country_region;
+  }
+  return value.province;
+}
+export function isValidRow(row, column, includeEmpty) {
+  const {
+    type: columnType
+  } = column;
+  if (includeEmpty || columnType === CellType.CHECKBOX) return true;
+  let cellValue;
+  if (FORMULA_COLUMN_TYPES.includes(columnType) || columnType === CellType.LINK) {
+    cellValue = row[column['id']] ? row[column['id']] : null;
+  } else if (columnType === CellType.GEOLOCATION) {
+    const value = row[column['id']];
+    const {
+      geo_format
+    } = column.data;
+    return isEmptyGeolocationCell(value, geo_format);
+  } else {
+    cellValue = row[column['id']];
+  }
+  return cellValue || cellValue === 0;
+}
+export function sortStatisticData(statistics, sort_type) {
+  statistics.sort((currResult, nextResult) => {
+    let {
+      value: current
+    } = currResult;
+    let {
+      value: next
+    } = nextResult;
+    if (!current && current !== 0) {
+      return -1;
+    }
+    if (!next && next !== 0) {
+      return 1;
+    }
+    if (sort_type === 'ascending') {
+      return current > next ? 1 : -1;
+    } else {
+      return current > next ? -1 : 1;
+    }
+  });
+}
+export function getTotal(summary_column_key, summary_column_type, summary_type, summary_method) {
+  let rows = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  let rowsLength = rows.length;
+  let total;
+  if (summary_type === STATISTICS_COUNT_TYPE.COUNT) {
+    total = rowsLength;
+    return total;
+  }
+  if (summary_type === STATISTICS_COUNT_TYPE.ADVANCED) {
+    switch (summary_method) {
+      case 'Distinct_values':
+        {
+          let count = 0;
+          let existMap = {};
+          rows.forEach(r => {
+            console.log(r);
+            let num;
+            if (FORMULA_COLUMN_TYPES.includes(summary_column_type)) {
+              num = r[summary_column_key];
+              num = Array.isArray(num) ? num[0] : num;
+            } else {
+              num = r[summary_column_key];
+            }
+            if (!num) {
+              if (num === 0) {
+                num = '0';
+              } else {
+                num = !!num;
+              }
+            }
+            if (!existMap[num]) {
+              existMap[num] = true;
+              count++;
+            }
+          });
+          total = count;
+          break;
+        }
+      case 'Sum':
+      case 'Mean':
+        {
+          let sum = 0;
+          let validNumbersCount = 0;
+          rows.forEach(r => {
+            let num;
+            if (FORMULA_COLUMN_TYPES.includes(summary_column_type)) {
+              num = r[summary_column_key];
+              num = Array.isArray(num) ? num[0] : num;
+            } else {
+              num = r[summary_column_key];
+            }
+            if (isNumber(num)) {
+              validNumbersCount++;
+              sum += num;
+            }
+          });
+          if (summary_method === 'Sum') {
+            total = Number.parseFloat(sum.toFixed(8));
+          } else if (summary_method === 'Mean') {
+            total = validNumbersCount === 0 ? 0 : Number.parseFloat((sum / validNumbersCount).toFixed(8));
+          }
+          break;
+        }
+      case 'Max':
+      case 'Min':
+        {
+          if (rowsLength > 0) {
+            let result = rows.reduce((current, next) => {
+              let currentValue, nextValue;
+              if (FORMULA_COLUMN_TYPES.includes(summary_column_type)) {
+                currentValue = current[summary_column_key];
+                nextValue = next[summary_column_key];
+                currentValue = Array.isArray(currentValue) ? currentValue[0] : currentValue;
+                nextValue = Array.isArray(nextValue) ? nextValue[0] : nextValue;
+              } else {
+                currentValue = current[summary_column_key];
+                nextValue = next[summary_column_key];
+              }
+              if (!nextValue && nextValue !== 0) {
+                return current;
+              }
+              let isNextGreater = currentValue < nextValue;
+              if (summary_method === 'Min') {
+                return isNextGreater ? current : next;
+              } else {
+                return isNextGreater ? next : current;
+              }
+            });
+            if (FORMULA_COLUMN_TYPES.includes(summary_column_type)) {
+              total = result[summary_column_key];
+              total = Array.isArray(total) ? total[0] : total;
+            } else {
+              total = result[summary_column_key];
+            }
+          }
+          break;
+        }
+      default:
+        {
+          break;
+        }
+    }
+  }
+  return total || 0;
+}
+export function getClientFormulaDisplayString(value, columnData) {
+  let {
+    collaborators = []
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!columnData || !value && value !== 0) return '';
+  const {
+    result_type,
+    array_type
+  } = columnData;
+  if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+    if (COLLABORATOR_COLUMN_TYPES.includes(array_type)) {
+      if (!value) {
+        return null;
+      }
+      const collaboratorList = Array.isArray(value) ? value : [value];
+      return getCollaboratorsName(collaborators, collaboratorList);
+    }
+  }
+  return getFormulaDisplayString(value, columnData, {
+    collaborators
+  });
+}
+export function getCollaboratorsName(emails, collaborators) {
+  if (!emails) {
+    return null;
+  }
+  let collaboratorsName = [];
+  emails.forEach(email => {
+    const collaborator = collaborators.find(collaborator => collaborator.email === email);
+    if (collaborator) {
+      collaboratorsName.push(collaborator.name);
+    }
+  });
+  if (collaboratorsName.length === 0) {
+    return '';
+  }
+  return collaboratorsName.join(', ');
+}
+export function getColorFromSingleSelectColumn(column, name) {
+  let {
+    type: columnType,
+    data: columnData
+  } = column;
+  if (columnType === CellType.SINGLE_SELECT) {
+    let options = columnData ? columnData.options : [];
+    let selectedOption = options.find(o => {
+      let id = name;
+      if (Array.isArray(name)) {
+        id = name[0];
+      }
+      return o.id === id;
+    });
+    let {
+      color
+    } = selectedOption || {};
+    if (selectedOption) {
+      return color;
+    }
+  }
+}
+export function getFormattedLabel(column, name, collaborators) {
+  let {
+    type: columnType,
+    data: columnData
+  } = column;
+  if (columnType === CellType.SINGLE_SELECT || columnType === CellType.MULTIPLE_SELECT) {
+    let options = columnData ? columnData.options : [];
+    let selectedOption = options.find(o => {
+      let id = name;
+      if (Array.isArray(name)) {
+        id = name[0];
+      }
+      return o.id === id;
+    });
+    let {
+      name: optionName
+    } = selectedOption || {};
+    if (selectedOption) {
+      return optionName;
+    }
+  } else if (columnType === CellType.COLLABORATOR) {
+    let collaborator = collaborators.find(item => {
+      let email = name;
+      if (Array.isArray(name)) {
+        email = name[0];
+      }
+      return item.email === email;
+    });
+    if (collaborator) {
+      return collaborator.name;
+    }
+  } else if (columnType === CellType.CREATOR || columnType === CellType.LAST_MODIFIER) {
+    if (name === 'anonymous') {
+      return name;
+    } else {
+      let collaborator = collaborators.find(item => item.email === name);
+      if (collaborator) {
+        return collaborator.name;
+      }
+    }
+  } else if (columnType === CellType.LINK) {
+    return getClientFormulaDisplayString([name], columnData, {
+      collaborators
+    });
+  } else if (columnType === CellType.CHECKBOX) {
+    // return name == 'true' ? intl.get('Checked') : intl.get('Unchecked');
+    return name === 'true' ? 'Checked' : 'Unchecked';
+  } else if (FORMULA_COLUMN_TYPES.includes(columnType)) {
+    let {
+      result_type
+    } = columnData || {};
+    if (!name && !isNumber(name)) return '';
+    if (result_type === 'number') {
+      let valueNumber = parseFloat(name);
+      return isNumber(valueNumber) ? getNumberDisplayString(valueNumber, column.data) : name;
+    }
+  }
+  if (!name) {
+    return '';
+  }
+  return name;
+}
+export function getLabelFontSize(statItem) {
+  const {
+    label_font_size
+  } = statItem;
+  return isNumber(label_font_size) ? label_font_size : DEFAULT_LABEL_FONT_SIZE;
+}
+export function getInitLabelFontSize(chart) {
+  const {
+    type,
+    label_font_size
+  } = chart;
+  if (type === STAT_TYPE.BASIC_NUMBER_CARD || type === STAT_TYPE.TREND_CHART) {
+    return isNumber(label_font_size) ? label_font_size : 4;
+  }
+  return getLabelFontSize(chart);
+}
+export function getInitYAxisSummaryMethod(y_axis_summary_method, type) {
+  if (Y_AXIS_SUPPORT_ROW_COUNT_CHARTS.includes(type)) {
+    return y_axis_summary_method || STATISTICS_COUNT_TYPE.ROW_COUNT;
+  }
+  if (y_axis_summary_method === STATISTICS_COUNT_TYPE.ROW_COUNT) {
+    return STATISTICS_COUNT_TYPE.MAX;
+  }
+  return y_axis_summary_method;
+}
+export function getChartDisplayLabels(containerWidth, minItemWidth, statistics) {
+  let labels = [];
+  let labelCount = Math.floor(containerWidth / minItemWidth);
+  labelCount = labelCount % 2 ? labelCount + 1 : labelCount;
+  let avg = Math.round(statistics.length / labelCount);
+  avg = avg > 2 ? avg : 2;
+  Array.isArray(statistics) && statistics.forEach((v, i) => {
+    if (i % avg === 0) {
+      labels.push(v.name);
+    }
+  });
+  return labels;
+}
+export function updateChartRows(results, index, name, row) {
+  let updatedResult;
+  if (index > -1) {
+    updatedResult = results[index];
+    updatedResult.rows.push(row);
+    results[index] = updatedResult;
+  } else {
+    updatedResult = {
+      name,
+      rows: [row]
+    };
+    results.push(updatedResult);
+  }
+}
+export function updateChartValue(summary_column_key, summary_column_type, summary_type, summary_method) {
+  let results = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  summary_type = summary_type || 'count';
+  Array.isArray(results) && results.forEach((item, index) => {
+    const {
+      rows
+    } = item;
+    let updated = _objectSpread({}, item);
+    updated.value = getTotal(summary_column_key, summary_column_type, summary_type, summary_method, rows);
+    results[index] = updated;
+  });
+}
+export function sortStatistics(statistics, column, sort_key) {
+  let {
+    type: column_type,
+    data
+  } = column;
+  let sortType = 'up';
+  let option_id_index_map = {};
+  if (column_type === CellType.SINGLE_SELECT) {
+    const {
+      options
+    } = data || {};
+    Array.isArray(options) && options.forEach((option, index) => {
+      option_id_index_map[option.id] = index;
+    });
+  }
+  statistics.sort((currResult, nextResult) => {
+    let {
+      [sort_key]: current
+    } = currResult;
+    let {
+      [sort_key]: next
+    } = nextResult;
+    if (!current && current !== 0) {
+      return -1;
+    }
+    if (!next && next !== 0) {
+      return 1;
+    }
+    if (SUPPORT_SORT_COLUMNS.includes(column_type)) {
+      switch (column_type) {
+        case CellType.NUMBER:
+          {
+            if (current) {
+              current = current - 0;
+            }
+            if (next) {
+              next = next - 0;
+            }
+            return sortNumber(current, next, sortType);
+          }
+        case CellType.DATE:
+        case CellType.CTIME:
+        case CellType.MTIME:
+          {
+            return sortDate(current, next, sortType);
+          }
+        case CellType.SINGLE_SELECT:
+        case CellType.MULTIPLE_SELECT:
+          {
+            return sortSingleSelect(current, next, {
+              sort_type: sortType,
+              option_id_index_map
+            });
+          }
+        case CellType.FORMULA:
+        case CellType.LINK_FORMULA:
+          {
+            let {
+              result_type
+            } = data || {};
+            if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+              if (current) {
+                current = current - 0;
+              }
+              if (next) {
+                next = next - 0;
+              }
+              return sortNumber(current, next, sortType);
+            }
+            return sortText(current, next, sortType);
+          }
+        default:
+          {
+            return sortText(current, next, sortType);
+          }
+      }
+    }
+    return 0;
+  });
+}

package/dist/basic-sdk/extension/plugins/chart/chart-utils/common-utils/dtable-utils.js

@@ -0,0 +1,144 @@
+import { CellType, FORMULA_RESULT_TYPE, getNumberDisplayString } from 'dtable-utils';
+import { DATE_COLUMN_TYPES, FORMULA_COLUMN_TYPES, MULTIPLE_CELL_VALUE_COLUMN_TYPES, NAME_FIELD_COLUMN_TYPES } from '../../constants/special-column-types';
+const MIRROR_COLUMN_LIST = [CellType.TEXT, CellType.NUMBER, CellType.CTIME, CellType.MTIME, CellType.DATE, CellType.COLLABORATOR, CellType.AUTO_NUMBER, CellType.FORMULA, CellType.GEOLOCATION, CellType.URL, CellType.SINGLE_SELECT, CellType.LINK, CellType.CREATOR, CellType.LAST_MODIFIER, CellType.DURATION, CellType.EMAIL];
+class DtableUtils {
+  static isArrayCellValue(columnType) {
+    return MULTIPLE_CELL_VALUE_COLUMN_TYPES.includes(columnType);
+  }
+}
+DtableUtils.getTableById = (value, table_id) => {
+  const tables = value.tables;
+  return tables.find(table => table._id === table_id);
+};
+DtableUtils.getViewById = (table, view_id) => {
+  const views = table.views;
+  return views.find(view => view._id === view_id);
+};
+DtableUtils.getColumnByKey = (table, columnKey) => {
+  const columns = table.columns;
+  return columns.find(column => column.key === columnKey);
+};
+DtableUtils.isNumericColumn = column => {
+  const {
+    type,
+    data
+  } = column;
+  if (type === CellType.NUMBER) {
+    return true;
+  }
+  if (FORMULA_COLUMN_TYPES.includes(type)) {
+    const {
+      result_type,
+      array_type
+    } = data || {};
+    return result_type === FORMULA_RESULT_TYPE.NUMBER || result_type === FORMULA_RESULT_TYPE.ARRAY && array_type === CellType.NUMBER;
+  }
+  return false;
+};
+DtableUtils.getCellValue = (row, formulaRow, column) => {
+  const {
+    type,
+    key
+  } = column;
+  if (FORMULA_COLUMN_TYPES.includes(type)) {
+    const cellValue = formulaRow && formulaRow[key];
+    if (Array.isArray(cellValue)) {
+      return cellValue[0];
+    }
+    return cellValue;
+  }
+  return row[key];
+};
+DtableUtils.isDateColumn = column => {
+  if (!column) return false;
+  const {
+    type,
+    data = {}
+  } = column;
+  return DATE_COLUMN_TYPES.includes(type) || FORMULA_COLUMN_TYPES.includes(type) && data.result_type && data.result_type === FORMULA_RESULT_TYPE.DATE;
+};
+DtableUtils.isTextColumn = column => {
+  if (!column) return false;
+  const {
+    type
+  } = column;
+  return NAME_FIELD_COLUMN_TYPES.includes(type);
+};
+DtableUtils.isMapColumn = column => {
+  if (!column) return false;
+  const {
+    type,
+    data
+  } = column;
+  if (type === CellType.GEOLOCATION) {
+    const {
+      geo_format
+    } = data || {};
+    if (geo_format === 'lng_lat' || geo_format === 'country_region') {
+      return false;
+    }
+    return true;
+  }
+  if (FORMULA_COLUMN_TYPES.includes(type)) {
+    const {
+      result_type,
+      array_type,
+      array_data
+    } = data || {};
+    if (result_type !== FORMULA_RESULT_TYPE.ARRAY || array_type !== CellType.GEOLOCATION) {
+      return false;
+    }
+    const {
+      geo_format
+    } = array_data || {};
+    if (geo_format === 'lng_lat' || geo_format === 'country_region') {
+      return false;
+    }
+    return true;
+  }
+  return false;
+};
+DtableUtils.isWorldMapColumn = column => {
+  if (!column) return false;
+  const {
+    type,
+    data
+  } = column;
+  if (type === CellType.TEXT) return true;
+  if (type === CellType.GEOLOCATION) {
+    const {
+      geo_format
+    } = data || {};
+    if (geo_format === 'country_region') {
+      return true;
+    }
+  }
+  if (FORMULA_COLUMN_TYPES.includes(type)) {
+    const {
+      data
+    } = column;
+    const {
+      result_type,
+      array_type,
+      array_data
+    } = data || {};
+    if (result_type !== FORMULA_RESULT_TYPE.ARRAY || array_type !== CellType.GEOLOCATION) {
+      return false;
+    }
+    const {
+      geo_format
+    } = array_data || {};
+    if (geo_format === 'country_region') {
+      return true;
+    }
+  }
+  return false;
+};
+DtableUtils.isMirrorColumn = column => {
+  if (!column) return false;
+  return MIRROR_COLUMN_LIST.includes(column.type);
+};
+DtableUtils.getNumberDisplayString = (value, columnData) => {
+  return getNumberDisplayString(value, columnData);
+};
+export default DtableUtils;

package/dist/basic-sdk/extension/plugins/chart/chart-utils/histogram-bar-utils.js

@@ -0,0 +1,83 @@
+import DtableUtils from './common-utils/dtable-utils';
+import { isValidRow, sortStatisticData, sortStatistics, updateChartRows, updateChartValue } from '../chart-utils/common-utils/base-utils';
+import { DATE_COLUMN_TYPES, GEOLOCATION_COLUMN_OPTIONS } from '../constants/special-column-types';
+import { DATA_SORT_TYPE } from '../constants';
+export const calculateStat = (statItem, metaData, rows) => {
+  let {
+    // table_id,
+    // view_id: viewId,
+    x_axis_column_key: groupbyColumnKey,
+    x_axis_date_granularity: groupbyDateGranularity,
+    x_axis_geolocation_granularity: groupbyGeolocationGranularity,
+    x_axis_include_empty: includeEmpty,
+    y_axis_summary_type: summaryType,
+    y_axis_column_key: summaryColumnKey,
+    y_axis_summary_method: summaryMethod,
+    sort_type: sortType
+  } = statItem;
+  if (!metaData) return;
+  if (!rows) return;
+  if (!groupbyColumnKey) return;
+  const groupbyColumn = metaData.find(item => item.key === groupbyColumnKey);
+  if (!groupbyColumn) return;
+  const {
+    type: groupbyColumnType
+  } = groupbyColumn;
+  if (DATE_COLUMN_TYPES.includes(groupbyColumnType) && !groupbyDateGranularity) {
+    groupbyDateGranularity = 'month';
+  }
+  if (GEOLOCATION_COLUMN_OPTIONS.includes(groupbyColumnType) && !groupbyGeolocationGranularity) {
+    groupbyGeolocationGranularity = 'province';
+  }
+  const statRows = rows;
+  const isColumnDataAsAnArray = DtableUtils.isArrayCellValue(groupbyColumn.type);
+
+  // 1. group by stat data by groupby column
+  let results = []; // results = [{name: '', rows: [], value: ''}]
+  statRows.forEach(row => {
+    if (isValidRow(row, groupbyColumn, includeEmpty)) {
+      const name = row[groupbyColumn['id']];
+      if (isColumnDataAsAnArray) {
+        if (name.length === 0 && includeEmpty) {
+          const nameIndex = results.findIndex(r => r.name === name);
+          updateChartRows(results, nameIndex, null, row);
+        } else {
+          name.forEach(name => {
+            const nameIndex = results.findIndex(r => r.name === name);
+            updateChartRows(results, nameIndex, name, row);
+          });
+        }
+      } else {
+        const nameIndex = results.findIndex(r => r.name === name);
+        updateChartRows(results, nameIndex, name, row);
+      }
+    }
+  });
+
+  // 2. reconcile stat data by summary_type
+  const summaryColumn = metaData.find(item => item.key === groupbyColumnKey);
+  const {
+    type: summaryColumnType
+  } = summaryColumn || {};
+  const summarYaxisColumn = metaData.find(item => item.key === summaryColumnKey);
+  if (summarYaxisColumn) {
+    summaryColumnKey = summarYaxisColumn['name'];
+  }
+  updateChartValue(summaryColumnKey, summaryColumnType, summaryType, summaryMethod, results);
+  let newSortType = sortType;
+  if (newSortType === DATA_SORT_TYPE.ASCENDING) {
+    newSortType = DATA_SORT_TYPE.DESCENDING;
+  } else if (newSortType === DATA_SORT_TYPE.DESCENDING) {
+    newSortType = DATA_SORT_TYPE.ASCENDING;
+  }
+
+  // 3. sort stat data
+  if (sortType) {
+    // sort statistic value
+    sortStatisticData(results, sortType);
+  } else {
+    // sort statistic label
+    sortStatistics(results, groupbyColumn, 'name');
+  }
+  return results;
+};

package/dist/basic-sdk/extension/plugins/chart/constants/date-constants.js

@@ -0,0 +1,9 @@
+export const DATE_GRANULARITY = {
+  DAY: 'day',
+  WEEK: 'week',
+  MONTH: 'month',
+  QUARTER: 'quarter',
+  YEAR: 'year'
+};
+export const DATE_GRANULARITIES = [DATE_GRANULARITY.DAY, DATE_GRANULARITY.WEEK, DATE_GRANULARITY.MONTH, DATE_GRANULARITY.QUARTER, DATE_GRANULARITY.YEAR];
+export const DEFAULT_DATE_GRANULARITY = DATE_GRANULARITY.MONTH;

package/dist/basic-sdk/extension/plugins/chart/constants/geolocation-constants.js

@@ -0,0 +1,11 @@
+export const GEOLOCATION_GRANULARITY = {
+  PROVINCE: 'province',
+  CITY: 'city',
+  DISTRICT: 'district'
+};
+export const GEOLOCATION_GRANULARITIES = [GEOLOCATION_GRANULARITY.PROVINCE, GEOLOCATION_GRANULARITY.CITY, GEOLOCATION_GRANULARITY.DISTRICT];
+export const DEFAULT_GEOLOCATION_GRANULARITY_MAP = {
+  PROVINCE: 'province',
+  PROVINCE_CITY: 'province_city',
+  GEOLOCATION: 'geolocation'
+};