dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/utils/export-table-utils.js

@@ -9,6 +9,8 @@ var _dayjs = _interopRequireDefault(require("dayjs"));
 var _reactIntlUniversal = _interopRequireDefault(require("react-intl-universal"));
 var _dtableUtils = require("dtable-utils");
 var _cellValue = require("./cell-value");
+var _column = require("./column");
+var _collaborator = require("./collaborator");
 var _constants = require("../constants");
 var _pivotTable = require("./pivot-table");
 const isEmptyName = title => {
@@ -21,6 +23,73 @@ const isSummaryDateColumn = summaryColumn => {
   } = summaryColumn;
   return type !== _dtableUtils.CellType.LINK && (0, _dtableUtils.isDateColumn)(summaryColumn);
 };
+
+// eslint-disable-next-line
+const getTableValueDisplayName = (value, column) => {
+  let {
+    type,
+    data
+  } = column || {};
+  let {
+    collaborators
+  } = window.app.state;
+  switch (type) {
+    case _dtableUtils.CellType.SINGLE_SELECT:
+    case _dtableUtils.CellType.MULTIPLE_SELECT:
+      {
+        let options = (0, _column.getSelectColumnOptions)(column);
+        let option = (0, _dtableUtils.getOption)(options, value) || {};
+        return option.name;
+      }
+    case _dtableUtils.CellType.COLLABORATOR:
+      {
+        let collaborator = (0, _dtableUtils.getCollaborator)(collaborators, value) || {};
+        return collaborator.name;
+      }
+    case _dtableUtils.CellType.CREATOR:
+    case _dtableUtils.CellType.LAST_MODIFIER:
+      {
+        let collaborator = (0, _collaborator.getKnownCreatorByEmail)(collaborators, value) || {};
+        return collaborator.name;
+      }
+    case _dtableUtils.CellType.NUMBER:
+      {
+        let valueNumber = parseFloat(value);
+        let displayValue = (0, _dtableUtils.isNumber)(valueNumber) ? (0, _dtableUtils.getNumberDisplayString)(valueNumber, data) : value;
+        return displayValue;
+      }
+    case _dtableUtils.CellType.DATE:
+      {
+        let displayValue = value;
+        if (value && value.split('-').length === 3) {
+          let format = (0, _column.getDateColumnFormat)(column);
+          let spaceIndex = format.indexOf(' ');
+          if (spaceIndex > -1) {
+            format = format.slice(0, spaceIndex);
+          }
+          displayValue = (0, _dayjs.default)(value).format(format);
+        }
+        return displayValue;
+      }
+    case _dtableUtils.CellType.FORMULA:
+    case _dtableUtils.CellType.LINK_FORMULA:
+      {
+        let displayValue = value;
+        let {
+          result_type
+        } = data || {};
+        if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.NUMBER) {
+          let valueNumber = parseFloat(value);
+          displayValue = (0, _dtableUtils.isNumber)(valueNumber) ? (0, _dtableUtils.getNumberDisplayString)(valueNumber, data) : value;
+        }
+        return displayValue;
+      }
+    default:
+      {
+        return value;
+      }
+  }
+};
 const getValidValueForColumn = (column, value) => {
   if (!column) return '';
   const {

package/es/utils/index.js

@@ -3,24 +3,101 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getEventClassName = void 0;
+Object.defineProperty(exports, "generateDefaultUser", {
+  enumerable: true,
+  get: function () {
+    return _collaborator.generateDefaultUser;
+  }
+});
+Object.defineProperty(exports, "getClientCellValueDisplayString", {
+  enumerable: true,
+  get: function () {
+    return _cellFormat.getClientCellValueDisplayString;
+  }
+});
+Object.defineProperty(exports, "getClientFormulaDisplayString", {
+  enumerable: true,
+  get: function () {
+    return _cellFormat.getClientFormulaDisplayString;
+  }
+});
+Object.defineProperty(exports, "getDateColumnFormat", {
+  enumerable: true,
+  get: function () {
+    return _column.getDateColumnFormat;
+  }
+});
+Object.defineProperty(exports, "getKnownCreatorByEmail", {
+  enumerable: true,
+  get: function () {
+    return _collaborator.getKnownCreatorByEmail;
+  }
+});
+Object.defineProperty(exports, "getSelectColumnOptions", {
+  enumerable: true,
+  get: function () {
+    return _column.getSelectColumnOptions;
+  }
+});
+Object.defineProperty(exports, "getTodayDate", {
+  enumerable: true,
+  get: function () {
+    return _dateFormat.getTodayDate;
+  }
+});
 Object.defineProperty(exports, "hasOwnProperty", {
   enumerable: true,
   get: function () {
     return _object.hasOwnProperty;
   }
 });
-exports.isMobile = exports.isFunction = void 0;
+exports.hexToRgb = void 0;
+Object.defineProperty(exports, "isCellValueChanged", {
+  enumerable: true,
+  get: function () {
+    return _cellValue.isCellValueChanged;
+  }
+});
+Object.defineProperty(exports, "isEmptyObject", {
+  enumerable: true,
+  get: function () {
+    return _object.isEmptyObject;
+  }
+});
+exports.isMobile = void 0;
+Object.defineProperty(exports, "isSameObject", {
+  enumerable: true,
+  get: function () {
+    return _object.isSameObject;
+  }
+});
+Object.defineProperty(exports, "searchRows", {
+  enumerable: true,
+  get: function () {
+    return _search.searchRows;
+  }
+});
+Object.defineProperty(exports, "translateCalendar", {
+  enumerable: true,
+  get: function () {
+    return _dateFormat.translateCalendar;
+  }
+});
+var _cellFormat = require("./cell-format");
 var _object = require("./object");
-const isFunction = functionToCheck => {
-  const getType = {};
-  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
-};
-exports.isFunction = isFunction;
-const getEventClassName = e => {
-  // svg mouseEvent event.target.className is an object
-  if (!e || !e.target) return '';
-  return e.target.getAttribute('class') || '';
+var _cellValue = require("./cell-value");
+var _collaborator = require("./collaborator");
+var _column = require("./column");
+var _dateFormat = require("./date-format");
+var _search = require("./search");
+const hexToRgb = hex => {
+  hex = hex.replace('#', '');
+  const bigint = parseInt(hex, 16);
+  return {
+    r: bigint >> 16 & 255,
+    g: bigint >> 8 & 255,
+    b: bigint & 255
+  };
 };
-exports.getEventClassName = getEventClassName;
+exports.hexToRgb = hexToRgb;
 const isMobile = exports.isMobile = typeof window !== 'undefined' && (window.innerWidth < 768 || navigator.userAgent.toLowerCase().match(/(ipod|ipad|iphone|android|coolpad|mmp|smartphone|midp|wap|xoom|symbian|j2me|blackberry|wince)/i) != null);

package/es/utils/map.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRegionScaleOffsets = exports.getGeoGranularityByLevel = exports.fixMapGeoGranularity = exports.fixGeoGranularity = void 0;
+var _constants = require("../constants");
+var _map = require("../constants/map");
+var _regions = require("../constants/regions");
+const COUNTY_SCALE_WIDTH = 5.95;
+const COUNTY_SCALE_HEIGHT = 4.37;
+const getGeoGranularityByLevel = mapLevel => {
+  switch (mapLevel) {
+    case _map.MAP_LEVEL.PROVINCE:
+      {
+        return _constants.GEOLOCATION_GRANULARITY.CITY;
+      }
+    case _map.MAP_LEVEL.CITY:
+      {
+        return _constants.GEOLOCATION_GRANULARITY.DISTRICT;
+      }
+    default:
+      {
+        // default as 'country'
+        return _constants.GEOLOCATION_GRANULARITY.PROVINCE;
+      }
+  }
+};
+exports.getGeoGranularityByLevel = getGeoGranularityByLevel;
+const fixGeoGranularity = _ref => {
+  let {
+    mapLevel,
+    mapLocation
+  } = _ref;
+  if (!mapLevel || mapLevel === _map.MAP_LEVEL.COUNTRY || !mapLocation) {
+    return _constants.GEOLOCATION_GRANULARITY.PROVINCE;
+  }
+
+  // e.g. Beijing
+  const {
+    province: provinceName,
+    city: cityName
+  } = mapLocation;
+  if (provinceName && _map.MUNICIPALITIES.includes(provinceName)) {
+    return _constants.GEOLOCATION_GRANULARITY.DISTRICT;
+  }
+
+  // e.g. HongKong
+  const selectedProvince = provinceName && _regions.regions.find(province => province.name === provinceName);
+  if (selectedProvince && selectedProvince.disable_drill_down) {
+    return _constants.GEOLOCATION_GRANULARITY.PROVINCE;
+  }
+  const cities = selectedProvince && selectedProvince.cities;
+  const selectedCity = cities && cityName && cities.find(city => city.name === cityName);
+  if (mapLevel === _map.MAP_LEVEL.CITY && selectedCity && selectedCity.disable_drill_down) {
+    return _constants.GEOLOCATION_GRANULARITY.CITY;
+  }
+
+  // others
+  return getGeoGranularityByLevel(mapLevel);
+};
+exports.fixGeoGranularity = fixGeoGranularity;
+const fixMapGeoGranularity = chart => {
+  const {
+    type,
+    map_level,
+    map_location
+  } = chart;
+  if (type !== _constants.STAT_TYPE.MAP && type !== _constants.STAT_TYPE.MAP_BUBBLE) {
+    return chart.geolocation_granularity;
+  }
+  return fixGeoGranularity({
+    mapLevel: map_level,
+    mapLocation: map_location
+  });
+};
+exports.fixMapGeoGranularity = fixMapGeoGranularity;
+const getRegionScaleOffsets = (mapLevel, mapLocation) => {
+  const countryScaleOffsets = {
+    scale_w: COUNTY_SCALE_WIDTH,
+    scale_h: COUNTY_SCALE_HEIGHT
+  };
+  switch (mapLevel) {
+    case _map.MAP_LEVEL.PROVINCE:
+      {
+        const provinceName = mapLocation && mapLocation.province;
+        const province = provinceName && _regions.regions.find(province => province.name === provinceName);
+        if (!province) return countryScaleOffsets;
+        return {
+          scale_w: province.scale_w,
+          scale_h: province.scale_h
+        };
+      }
+    case _map.MAP_LEVEL.CITY:
+      {
+        const provinceName = mapLocation && mapLocation.province;
+        const province = provinceName && _regions.regions.find(province => province.name === provinceName);
+        const cities = province && province.cities;
+        const cityName = mapLocation.city;
+        const city = cityName && Array.isArray(cities) && cities.find(city => city.name === cityName);
+        if (!city) return countryScaleOffsets;
+        return {
+          scale_w: city.scale_w,
+          scale_h: city.scale_h
+        };
+      }
+    default:
+      {
+        // default as 'country'
+        return countryScaleOffsets;
+      }
+  }
+};
+exports.getRegionScaleOffsets = getRegionScaleOffsets;

package/es/utils/model.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getChartConfigValueFromKeys = exports.getChartConfigValueFromKey = void 0;
+var _object = require("./object");
+const getChartConfigValueFromKey = (key, object) => {
+  if (!(0, _object.hasOwnProperty)(object, key)) {
+    return null;
+  }
+  return object[key];
+};
+exports.getChartConfigValueFromKey = getChartConfigValueFromKey;
+const getChartConfigValueFromKeys = (keys, object) => {
+  const existKey = keys.find(key => (0, _object.hasOwnProperty)(object, key));
+  return existKey ? object[existKey] : null;
+};
+exports.getChartConfigValueFromKeys = getChartConfigValueFromKeys;

package/es/utils/row-utils.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCellValue = getCellValue;
+exports.isValidRow = exports.isEmptyGeolocationCell = exports.getFormattedLabel = void 0;
+var _dtableUtils = require("dtable-utils");
+var _utils = require("../utils");
+const isEmptyGeolocationCell = (cellValue, format) => {
+  if (!cellValue) return null;
+  if (format === 'lng_lat') {
+    return (cellValue.lng || cellValue.lng === 0) && (cellValue.lat || cellValue.lat === 0);
+  }
+  if (format === 'country_region') {
+    return cellValue.country_region;
+  }
+  return cellValue.province;
+};
+exports.isEmptyGeolocationCell = isEmptyGeolocationCell;
+const isValidRow = (row, formulaRow, column, includeEmpty) => {
+  const {
+    type: columnType,
+    key: columnKey
+  } = column;
+  if (includeEmpty || columnType === _dtableUtils.CellType.CHECKBOX) return true;
+  if (columnType === _dtableUtils.CellType.GEOLOCATION) {
+    const {
+      geo_format
+    } = column.data;
+    return isEmptyGeolocationCell(row[columnKey], geo_format);
+  }
+  let cellValue = row[columnKey];
+  if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[columnType] || columnType === _dtableUtils.CellType.LINK) {
+    cellValue = formulaRow ? formulaRow[columnKey] : null;
+  }
+  return cellValue || cellValue === 0;
+};
+exports.isValidRow = isValidRow;
+const getFormattedLabel = (column, name, collaborators) => {
+  let {
+    type: columnType,
+    data: columnData
+  } = column;
+  if (columnType === _dtableUtils.CellType.SINGLE_SELECT || columnType === _dtableUtils.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 === _dtableUtils.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 === _dtableUtils.CellType.CREATOR || columnType === _dtableUtils.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 === _dtableUtils.CellType.LINK) {
+    return (0, _utils.getClientFormulaDisplayString)(Array.isArray(name) ? name : [name], columnData, {
+      collaborators
+    });
+  } else if (columnType === _dtableUtils.CellType.CHECKBOX) {
+    return name === 'true' ? 'Checked' : 'Unchecked';
+  } else if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[columnType]) {
+    const {
+      result_type,
+      array_type
+    } = columnData || {};
+    if (!name && !(0, _dtableUtils.isNumber)(name)) return '';
+    if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.NUMBER) {
+      const valueNumber = parseFloat(name);
+      return (0, _dtableUtils.isNumber)(valueNumber) ? (0, _dtableUtils.getNumberDisplayString)(valueNumber, column.data) : name;
+    }
+    if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY) {
+      if (_dtableUtils.COLLABORATOR_COLUMN_TYPES.includes(array_type)) {
+        if ([_dtableUtils.CellType.CREATOR, _dtableUtils.CellType.LAST_MODIFIER].includes(array_type) && name === 'anonymous') {
+          return name;
+        }
+        const collaborator = collaborators.find(item => {
+          let email = name;
+          if (Array.isArray(name)) {
+            email = name[0];
+          }
+          return item.email === email;
+        });
+        if (collaborator) {
+          return collaborator.name;
+        }
+      }
+    }
+  }
+  if (!name) {
+    return '';
+  }
+  return name;
+};
+exports.getFormattedLabel = getFormattedLabel;
+function getCellValue(row, formulaRow, column) {
+  if (!column) return null;
+  const {
+    type,
+    key
+  } = column;
+  if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[type]) {
+    const cellValue = formulaRow && formulaRow[key];
+    if (Array.isArray(cellValue)) {
+      return cellValue[0];
+    }
+    return cellValue;
+  }
+  return row[key];
+}

package/es/utils/search.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.searchRows = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _dtableUtils = require("dtable-utils");
+var _column = require("./column");
+const SUPPORT_SEARCH_COLUMN_TYPES = [_dtableUtils.CellType.DATE, _dtableUtils.CellType.TEXT, _dtableUtils.CellType.LONG_TEXT, _dtableUtils.CellType.NUMBER, _dtableUtils.CellType.URL, _dtableUtils.CellType.EMAIL, _dtableUtils.CellType.SINGLE_SELECT, _dtableUtils.CellType.CTIME, _dtableUtils.CellType.MTIME, _dtableUtils.CellType.MULTIPLE_SELECT, _dtableUtils.CellType.LAST_MODIFIER, _dtableUtils.CellType.CREATOR, _dtableUtils.CellType.COLLABORATOR, _dtableUtils.CellType.LINK, _dtableUtils.CellType.FORMULA, _dtableUtils.CellType.LINK_FORMULA, _dtableUtils.CellType.AUTO_NUMBER, _dtableUtils.CellType.GEOLOCATION, _dtableUtils.CellType.DURATION];
+const searchRows = (rows, columns, val, processRow) => {
+  let dtableCollaborators = window.app.collaboratorsCache || [];
+  let collaborators = window.app.state.collaborators;
+  let searchResult = [];
+  rows.forEach(row => {
+    let column = columns.find(column => {
+      const {
+        type: columnType,
+        key: columnKey
+      } = column;
+      if (!SUPPORT_SEARCH_COLUMN_TYPES.includes(columnType)) {
+        return false;
+      }
+      const cellValue = row[columnKey];
+      if (cellValue) {
+        let text;
+        if (columnType === _dtableUtils.CellType.LONG_TEXT) {
+          text = cellValue.text;
+        } else if (columnType === _dtableUtils.CellType.NUMBER || columnType === _dtableUtils.CellType.DURATION) {
+          text = (0, _dtableUtils.getNumberDisplayString)(cellValue, column.data);
+        } else if (columnType === _dtableUtils.CellType.SINGLE_SELECT) {
+          const options = (0, _column.getSelectColumnOptions)(column);
+          const option = options.find(option => option.id === cellValue);
+          text = option ? option.name : '';
+        } else if (columnType === _dtableUtils.CellType.MULTIPLE_SELECT) {
+          const options = (0, _column.getSelectColumnOptions)(column);
+          text = (0, _dtableUtils.getMultipleOptionName)(options, cellValue);
+        } else if (columnType === _dtableUtils.CellType.COLLABORATOR) {
+          text = (0, _dtableUtils.getCollaboratorsName)(collaborators, cellValue);
+        } else if (columnType === _dtableUtils.CellType.LAST_MODIFIER || columnType === _dtableUtils.CellType.CREATOR) {
+          if (cellValue === 'anonymous') {
+            text = cellValue;
+          } else {
+            let collaborator = collaborators.find(collaborator => collaborator.email === cellValue);
+            if (!collaborator) {
+              collaborator = dtableCollaborators[cellValue];
+            }
+            if (collaborator) {
+              text = collaborator.name;
+            }
+          }
+        } else if (columnType === _dtableUtils.CellType.GEOLOCATION) {
+          text = (0, _dtableUtils.getGeolocationDisplayString)(cellValue, column.data);
+        } else if (columnType === _dtableUtils.CellType.CTIME || columnType === _dtableUtils.CellType.MTIME) {
+          text = (0, _dayjs.default)(cellValue).format('YYYY-MM-DD HH:mm:ss');
+        } else {
+          text = cellValue;
+        }
+        if (!text || typeof text !== 'string') return false;
+        if (text.toLowerCase().indexOf(val.toLowerCase()) > -1) {
+          return true;
+        }
+      }
+      return false;
+    });
+    if (column) {
+      searchResult.push(processRow(row));
+    }
+  });
+  return searchResult;
+};
+exports.searchRows = searchRows;