dtable-utils 0.0.1

package/lib/cell-value-get/date.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dayjs = require('dayjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+/**
+ * Get formatted date
+ * @param {string} date e.g. "2023-07-06 11:30"
+ * @param {string} format e.g. "YYYY-MM-DD"
+ * @returns formatted date, string
+ */
+var getDateDisplayString = function getDateDisplayString(date, format) {
+  if (!date || typeof date !== 'string') {
+    return '';
+  }
+  var dateObj = dayjs__default["default"](date);
+  if (!dateObj.isValid()) return date;
+  switch (format) {
+    case 'D/M/YYYY':
+    case 'DD/MM/YYYY':
+      {
+        var formatValue = dateObj.format('YYYY-MM-DD');
+        var formatValueList = formatValue.split('-');
+        return "".concat(formatValueList[2], "/").concat(formatValueList[1], "/").concat(formatValueList[0]);
+      }
+    case 'D/M/YYYY HH:mm':
+    case 'DD/MM/YYYY HH:mm':
+      {
+        var formatValues = dateObj.format('YYYY-MM-DD HH:mm');
+        var formatValuesList = formatValues.split(' ');
+        var formatDateList = formatValuesList[0].split('-');
+        return "".concat(formatDateList[2], "/").concat(formatDateList[1], "/").concat(formatDateList[0], " ").concat(formatValuesList[1]);
+      }
+    case 'M/D/YYYY':
+      return dateObj.format('M/D/YYYY');
+    case 'M/D/YYYY HH:mm':
+      return dateObj.format('M/D/YYYY HH:mm');
+    case 'YYYY-MM-DD':
+      return dateObj.format('YYYY-MM-DD');
+    case 'YYYY-MM-DD HH:mm':
+      return dateObj.format('YYYY-MM-DD HH:mm');
+    case 'YYYY-MM-DD HH:mm:ss':
+      {
+        return dateObj.format('YYYY-MM-DD HH:mm:ss');
+      }
+    case 'DD.MM.YYYY':
+      return dateObj.format('DD.MM.YYYY');
+    case 'DD.MM.YYYY HH:mm':
+      return dateObj.format('DD.MM.YYYY HH:mm');
+    default:
+      // Compatible with older versions: if format is null, use defaultFormat
+      return dateObj.format('YYYY-MM-DD');
+  }
+};
+
+exports.getDateDisplayString = getDateDisplayString;

package/lib/cell-value-get/digital-sign.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get signature image url to display
+ * @param {object} digitalSign object, e.g. { sign_image_url: 'xxx' }
+ * @returns signature image url, string
+ */
+var getDigitalSignImageUrl = function getDigitalSignImageUrl(digitalSign) {
+  return digitalSign && digitalSign.sign_image_url || '';
+};
+
+exports.getDigitalSignImageUrl = getDigitalSignImageUrl;

package/lib/cell-value-get/duration.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var column = require('../constants/column.js');
+
+var getMathRoundedDuration = function getMathRoundedDuration(num, duration_format) {
+  var decimalDigits = column.DURATION_DECIMAL_DIGITS[duration_format];
+  if (decimalDigits < 1) {
+    return num;
+  }
+  var ratio = Math.pow(10, decimalDigits);
+  return Math.round(num * ratio) / ratio;
+};
+var getDurationDecimalSuffix = function getDurationDecimalSuffix(duration_format, decimal) {
+  if (duration_format === column.DURATION_FORMATS_MAP.H_MM_SS_S) {
+    return decimal === 0 ? '.0' : '';
+  }
+  if (duration_format === column.DURATION_FORMATS_MAP.H_MM_SS_SS) {
+    if (decimal === 0) {
+      return '.00';
+    }
+    if (decimal < 10) {
+      return '0';
+    }
+    return '';
+  }
+  if (duration_format === column.DURATION_FORMATS_MAP.H_MM_SS_SSS) {
+    if (decimal === 0) {
+      return '.000';
+    }
+    if (decimal < 10) {
+      return '00';
+    }
+    if (decimal < 100) {
+      return '0';
+    }
+  }
+  return '';
+};
+
+/**
+ * Get formatted duration.
+ * @param {number} duration e.g. 100
+ * @param {object} formats { duration_format: 'h:mm', ... }
+ * @returns formatted duration, string
+ */
+var getDurationDisplayString = function getDurationDisplayString(duration, formats) {
+  if (!duration && duration !== 0) return '';
+  var _ref = formats || {},
+    duration_format = _ref.duration_format;
+  duration_format = duration_format || column.DURATION_FORMATS_MAP.H_MM;
+  if (column.DURATION_FORMATS.findIndex(function (format) {
+    return format.type === duration_format;
+  }) < 0) {
+    return '';
+  }
+  if (duration === 0) {
+    return column.DURATION_ZERO_DISPLAY[duration_format];
+  }
+  var includeDecimal = duration_format.indexOf('.') > -1;
+  var positiveValue = Math.abs(duration);
+  if (!includeDecimal) {
+    positiveValue = Math.round(positiveValue);
+  }
+  positiveValue = getMathRoundedDuration(positiveValue, duration_format);
+  var decimalParts = String(positiveValue).split('.');
+  var decimalPartsLen = decimalParts.length;
+  var decimal = 0;
+  if (decimalPartsLen > 1) {
+    decimal = decimalParts[decimalPartsLen - 1];
+    decimal = decimal ? decimal - 0 : 0;
+  }
+  var decimalDigits = column.DURATION_DECIMAL_DIGITS[duration_format];
+  var decimalSuffix = getDurationDecimalSuffix(duration_format, decimal);
+  var hours = parseInt(positiveValue / 3600, 10);
+  var minutes = parseInt((positiveValue - hours * 3600) / 60, 10);
+  var displayString = duration < 0 ? '-' : '';
+  if (duration_format === column.DURATION_FORMATS_MAP.H_MM) {
+    displayString += "".concat(hours, ":").concat(minutes > 9 ? minutes : "0".concat(minutes));
+    return displayString;
+  }
+  var seconds = Number.parseFloat((positiveValue - hours * 3600 - minutes * 60).toFixed(decimalDigits));
+  minutes = minutes > 9 ? minutes : "0".concat(minutes);
+  seconds = seconds > 9 ? seconds : "0".concat(seconds);
+  displayString += "".concat(hours, ":").concat(minutes, ":").concat(seconds).concat(decimalSuffix);
+  return displayString;
+};
+
+exports.getDurationDisplayString = getDurationDisplayString;

package/lib/cell-value-get/geolocation.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isValidPosition = function isValidPosition(lng, lat) {
+  return (lng || lng === 0) && (lat || lat === 0);
+};
+
+/**
+ * Get formatted geolocation
+ * @param {object} loc
+ * @param {object} formats , e.g. { geo_format: 'xxx' }
+ * @param {bool} isBaiduMap Determine the way to connect latitude and longitude. Default as true
+ * @param {string} hyphen Used as a connector between province, city, district and detail. Default as empty string
+ * @returns formatted geolocation, string
+ */
+var getGeolocationDisplayString = function getGeolocationDisplayString(loc, formats) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+    _ref$isBaiduMap = _ref.isBaiduMap,
+    isBaiduMap = _ref$isBaiduMap === void 0 ? true : _ref$isBaiduMap,
+    _ref$hyphen = _ref.hyphen,
+    hyphen = _ref$hyphen === void 0 ? '' : _ref$hyphen;
+  if (!loc) {
+    return '';
+  }
+  var _ref2 = formats || {},
+    geo_format = _ref2.geo_format;
+  switch (geo_format) {
+    case 'lng_lat':
+      {
+        var _ref3 = loc || {},
+          lng = _ref3.lng,
+          lat = _ref3.lat;
+        if (!isValidPosition(lng, lat)) return '';
+        return isBaiduMap ? "".concat(lng, ", ").concat(lat) : "".concat(lat, ", ").concat(lng);
+      }
+    case 'country_region':
+      {
+        var _ref4 = loc || {},
+          country_region = _ref4.country_region;
+        return country_region || '';
+      }
+    case 'province':
+      {
+        var _ref5 = loc || {},
+          province = _ref5.province;
+        return province || '';
+      }
+    case 'province_city':
+      {
+        var _ref6 = loc || {},
+          _province = _ref6.province,
+          city = _ref6.city;
+        return "".concat(_province || '').concat(hyphen).concat(city || '').trim();
+      }
+    case 'province_city_district':
+      {
+        var _ref7 = loc || {},
+          _province2 = _ref7.province,
+          _city = _ref7.city,
+          district = _ref7.district;
+        return "".concat(_province2 || '').concat(hyphen).concat(_city || '').concat(hyphen).concat(district || '').trim();
+      }
+    default:
+      {
+        // default as 'geolocation'
+        var _ref8 = loc || {},
+          _province3 = _ref8.province,
+          _city2 = _ref8.city,
+          _district = _ref8.district,
+          detail = _ref8.detail;
+        if (!_province3 && !_city2 && !_district && !detail) return '';
+        return "".concat(_province3 || '').concat(hyphen).concat(_city2 || '').concat(hyphen).concat(_district || '').concat(hyphen).concat(detail || '').trim();
+      }
+  }
+};
+
+exports.getGeolocationDisplayString = getGeolocationDisplayString;

package/lib/cell-value-get/long-text.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get text from long-text to display.
+ * @param {object} longText e.g. { text: 'xxx' }
+ * @returns text from long-text, string
+ */
+var getLongtextDisplayString = function getLongtextDisplayString(longText) {
+  if (!longText) return '';
+  return longText.text || '';
+};
+
+exports.getLongtextDisplayString = getLongtextDisplayString;

package/lib/cell-value-get/number.js

@@ -0,0 +1,227 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../helper/number-precision/index.js');
+var column = require('../constants/column.js');
+var duration = require('./duration.js');
+
+var separatorMap = {
+  comma: ',',
+  dot: '.',
+  no: '',
+  space: ' '
+};
+
+/**
+ * removeZerosFromEnd('0.0100') // '0.01'
+ * @param {string} sNumber string of numbers
+ */
+var removeZerosFromEnd = function removeZerosFromEnd(sNumber) {
+  if (typeof sNumber !== 'string') return '';
+  if (sNumber.endsWith('0')) {
+    return sNumber.replace(/(?:\.0*|(\.\d+?)0+)$/, '$1');
+  }
+  return sNumber;
+};
+
+/**
+ * e.g. 1.23 // 2
+ * @param {number} number
+ * @returns digital length
+ */
+var getDecimalDigitsFromNumber = function getDecimalDigitsFromNumber(number) {
+  if (Number.isInteger(number)) {
+    return 0;
+  }
+  var decimalPart = String(number).split('.')[1];
+  var digitsLength = decimalPart ? decimalPart.length : 8;
+  return digitsLength > 8 ? 8 : digitsLength;
+};
+var toThousands = function toThousands(number, _ref) {
+  var formats = _ref.formats,
+    _ref$isCurrency = _ref.isCurrency,
+    isCurrency = _ref$isCurrency === void 0 ? true : _ref$isCurrency;
+  var _ref2 = formats || {},
+    _ref2$decimal = _ref2.decimal,
+    decimal = _ref2$decimal === void 0 ? 'dot' : _ref2$decimal,
+    _ref2$thousands = _ref2.thousands,
+    thousands = _ref2$thousands === void 0 ? 'no' : _ref2$thousands,
+    _ref2$precision = _ref2.precision,
+    precision = _ref2$precision === void 0 ? 2 : _ref2$precision,
+    _ref2$enable_precisio = _ref2.enable_precision,
+    enable_precision = _ref2$enable_precisio === void 0 ? false : _ref2$enable_precisio;
+
+  // handle numbers in scientific notation
+  if (String(number).includes('e')) {
+    if (number < 1 && number > -1) {
+      // 1.convert to non-scientific number
+      var numericString = number.toFixed(enable_precision ? precision : 8);
+
+      // 2.remove 0 from end of the number which not set precision. e.g. 0.100000
+      if (!enable_precision) {
+        numericString = removeZerosFromEnd(numericString);
+      }
+
+      // 3.remove minus from number which equal to 0. e.g. '-0.00'
+      if (parseFloat(numericString) === 0) {
+        return numericString.startsWith('-') ? numericString.substring(1) : numericString;
+      }
+      return numericString;
+    }
+    return number;
+  }
+  var decimalString = separatorMap[decimal];
+  var thousandsString = separatorMap[thousands];
+  var decimalDigits = enable_precision ? precision : getDecimalDigitsFromNumber(number);
+  var floatNumber = parseFloat(number.toFixed(decimalDigits));
+  var isMinus = floatNumber < 0;
+  var integer = Math.trunc(floatNumber);
+
+  // format decimal part
+  var decimalPart = String(Math.abs(index.NPminus(floatNumber, integer)).toFixed(decimalDigits)).slice(1);
+  if (!enable_precision) {
+    decimalPart = removeZerosFromEnd(decimalPart);
+  }
+  if (isCurrency) {
+    if (!enable_precision) {
+      decimalPart = decimalPart.length === 2 ? decimalPart = decimalPart.padEnd(3, '0') : (decimalPart.substring(0, 3) || '.').padEnd(3, '0');
+    }
+  }
+  decimalPart = decimalPart.replace(/./, decimalString);
+
+  // format integer part
+  var integerNumbers = [];
+  var counter = 0;
+  integer = Math.abs(integer).toString();
+  for (var i = integer.length - 1; i > -1; i--) {
+    counter += 1;
+    integerNumbers.unshift(integer[i]);
+    if (!(counter % 3) && i !== 0) {
+      integerNumbers.unshift(thousandsString);
+    }
+  }
+  return "".concat(isMinus ? '-' : '').concat(integerNumbers.join('')).concat(decimalPart);
+};
+
+/**
+ * Get formatted number
+ * @param {number} number e.g. 123
+ * @param {object} formats e.g. { format: 'number', decimal: 'dot', ... }
+ * @returns formatted number, string
+ */
+var getNumberDisplayString = function getNumberDisplayString(number, formats) {
+  var type = Object.prototype.toString.call(number);
+  if (type !== '[object Number]') {
+    // return formula internal errors directly.
+    if (type === '[object String]' && number.startsWith('#')) {
+      return number;
+    }
+    return '';
+  }
+  if (isNaN(number) || number === Infinity || number === -Infinity) return String(number);
+
+  // formats: old version maybe 'null'
+  var _ref3 = formats || {},
+    _ref3$format = _ref3.format,
+    format = _ref3$format === void 0 ? column.DEFAULT_NUMBER_FORMAT : _ref3$format;
+  switch (format) {
+    case 'number':
+      {
+        return toThousands(number, {
+          formats: formats,
+          isCurrency: false
+        });
+      }
+    case 'percent':
+      {
+        return "".concat(toThousands(Number.parseFloat((number * 100).toFixed(8)), {
+          formats: formats,
+          isCurrency: false
+        }), "%");
+      }
+    case 'yuan':
+      {
+        return "\uFFE5".concat(toThousands(number, {
+          formats: formats
+        }));
+      }
+    case 'dollar':
+      {
+        return "$".concat(toThousands(number, {
+          formats: formats
+        }));
+      }
+    case 'euro':
+      {
+        return "\u20AC".concat(toThousands(number, {
+          formats: formats
+        }));
+      }
+    case 'duration':
+      {
+        return duration.getDurationDisplayString(number, formats);
+      }
+    case 'custom_currency':
+      {
+        if (formats.currency_symbol_position === 'after') {
+          return "".concat(toThousands(number, {
+            formats: formats
+          })).concat(formats.currency_symbol || '');
+        }
+        return "".concat(formats.currency_symbol || '').concat(toThousands(number, {
+          formats: formats
+        }));
+      }
+    default:
+      {
+        return String(number);
+      }
+  }
+};
+
+/**
+ * Remove illegal characters
+ * @param {string} sNum e.g. "1。23"
+ * @param {string} format e.g. "number"
+ * @param {string} currencySymbol custom symbol
+ * @returns legal characters, string
+ */
+var replaceNumberNotAllowInput = function replaceNumberNotAllowInput(sNum, format, currencySymbol) {
+  if (!sNum) {
+    return '';
+  }
+  var fixedSNum = sNum.replace(/。/g, '.');
+  switch (format) {
+    case 'percent':
+      {
+        return fixedSNum.replace(/[^.-\d,%]/g, '');
+      }
+    case 'yuan':
+      {
+        return fixedSNum.replace(/[^.-\d¥￥,]/g, '');
+      }
+    case 'dollar':
+      {
+        return fixedSNum.replace(/[^.-\d$,]/g, '');
+      }
+    case 'euro':
+      {
+        return fixedSNum.replace(/[^.-\d€,]/g, '');
+      }
+    case 'custom_currency':
+      {
+        // eslint-disable-next-line
+        var reg = new RegExp('[^.-\d' + currencySymbol + ',]', 'g');
+        return fixedSNum.replace(reg, '');
+      }
+    default:
+      {
+        // default as number format
+        return fixedSNum.replace(/[^.-\d,]/g, '');
+      }
+  }
+};
+
+exports.getNumberDisplayString = getNumberDisplayString;
+exports.replaceNumberNotAllowInput = replaceNumberNotAllowInput;

package/lib/cell-value-get/option.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get option name of the given id
+ * @param {array} options e.g. [ { id: '', color: '', name: '' } ]
+ * @param {string} targetOptionID option id
+ * @returns option name, string
+ */
+var getOptionName = function getOptionName(options, targetOptionID) {
+  if (!targetOptionID || !Array.isArray(options)) return '';
+  var targetOption = options.find(function (option) {
+    return option.id === targetOptionID;
+  });
+  return targetOption ? targetOption.name : '';
+};
+
+/**
+ * Get concatenated options names of given ids.
+ * @param {array} options e.g. [ { id: '', color: '', name: '' }, ... ]
+ * @param {array} targetOptionsIds e.g. [ option.id, ... ]
+ * @returns concatenated options names, string. e.g. 'name1, name2'
+ */
+var getMultipleOptionName = function getMultipleOptionName(options, targetOptionsIds) {
+  if (!Array.isArray(targetOptionsIds) || !Array.isArray(options)) return '';
+  var selectedOptions = options.filter(function (option) {
+    return targetOptionsIds.includes(option.id);
+  });
+  if (selectedOptions.length === 0) return '';
+  return selectedOptions.map(function (option) {
+    return option.name;
+  }).join(', ');
+};
+
+exports.getMultipleOptionName = getMultipleOptionName;
+exports.getOptionName = getOptionName;

package/lib/cell-value-set/number.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../helper/number-precision/index.js');
+
+/**
+ * @param {string} sNumber e.g. '1.23'
+ * @param {string} format e.g. 'percent'
+ * @returns float number from string. e.g. '1.23' = 1.23
+ */
+var getFloatNumber = function getFloatNumber(sNumber, format) {
+  if (!sNumber && sNumber !== 0) {
+    return null;
+  }
+  if (typeof sNumber === 'number') return sNumber;
+  if (typeof sNumber !== 'string') return null;
+  var parsedNum = parseFloat(sNumber.replace(/[^.-\d]/g, ''));
+  if (format === 'percent' && !isNaN(parsedNum)) {
+    return index.NPdivide(parsedNum, 100);
+  }
+  return isNaN(parsedNum) ? null : parsedNum;
+};
+
+/**
+ * parse string to number depend on formats
+ * @param {string} sNum e.g. '1.23'
+ * @param {object} formats { format, decimal, ... }
+ * @returns parsed number
+ */
+var formatStringToNumber = function formatStringToNumber(sNum, formats) {
+  var _ref = formats || {},
+    format = _ref.format,
+    decimal = _ref.decimal,
+    thousands = _ref.thousands,
+    enable_precision = _ref.enable_precision,
+    precision = _ref.precision;
+  var value = sNum;
+  if (decimal && thousands && decimal === 'comma') {
+    if (thousands === 'dot') {
+      value = value.replace(/,/, '@');
+      value = value.replace(/\./g, ',');
+      value = value.replace(/@/, '.');
+    } else {
+      value = value.replace(/\./g, '');
+      value = value.replace(/,/, '.');
+    }
+  }
+  value = getFloatNumber(value, format);
+  if (enable_precision && value) {
+    var fixedPrecision = format === 'percent' ? precision + 2 : precision;
+    value = Number(parseFloat(value).toFixed(fixedPrecision));
+  }
+  return value;
+};
+
+exports.formatStringToNumber = formatStringToNumber;
+exports.getFloatNumber = getFloatNumber;

package/lib/column/common.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cellType = require('../constants/cell-type.js');
+var formula = require('../constants/formula.js');
+
+/**
+ * Get column type.
+ * @param {object} column { type: 'xxx', ... }
+ * @returns column type
+ */
+var getCheckType = function getCheckType(column) {
+  var type = column.type,
+    data = column.data;
+  if (formula.FORMULA_COLUMN_TYPES_MAP[type]) {
+    var _ref = data || {},
+      result_type = _ref.result_type,
+      array_type = _ref.array_type;
+    if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+      return array_type;
+    }
+    return result_type;
+  }
+  if (type === cellType.CellType.LINK) {
+    var _ref2 = data || {},
+      _array_type = _ref2.array_type;
+    return _array_type;
+  }
+  return type;
+};
+
+/**
+ * Get options from single-select/multiple-select column.
+ * @param {object} column e.g. { type, data: { options: [] } }
+ * @returns options, array
+ */
+var getColumnOptions = function getColumnOptions(column) {
+  if (!column || !column.data || !Array.isArray(column.data.options)) {
+    return [];
+  }
+  return column.data.options;
+};
+
+exports.getCheckType = getCheckType;
+exports.getColumnOptions = getColumnOptions;

package/lib/column/date.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var column = require('../constants/column.js');
+
+/**
+ * Check whether is date column:
+ *  - column type is date, ctime or mtime etc.
+ *  - column type is formula and result_type is date
+ *  - column type is link/link_fromula and array_type is date, ctime or mtime etc.
+ * @param {object} column e.g. { type, data }
+ * @returns true/false, bool
+ */
+var isDateColumn = function isDateColumn(column$1) {
+  var checkType = common.getCheckType(column$1);
+  return column.DATE_COLUMN_OPTIONS.includes(checkType);
+};
+
+exports.isDateColumn = isDateColumn;

package/lib/column/number.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var common = require('./common.js');
+var cellType = require('../constants/cell-type.js');
+var column = require('../constants/column.js');
+
+/**
+ * Check whether is numeric column:
+ *  - column type is number, duration or rate etc.
+ *  - column type is formula and result_type is number
+ *  - column type is link/link_formula and array_type is number, duration or rate etc.
+ * @param {object} column e.g. { type, data }
+ * @returns true/false, bool
+ */
+var isNumericColumn = function isNumericColumn(column$1) {
+  var checkType = common.getCheckType(column$1);
+  return column.NUMERIC_COLUMNS_TYPES.includes(checkType);
+};
+
+/**
+ * Check whether is number column:
+ *  - column type is number
+ *  - column type is formula and result_type is number
+ *  - column type is link/link_formula and array_type is number
+ * @param {object} column e.g. { type, data }
+ * @returns true/false, bool
+ */
+var isNumberColumn = function isNumberColumn(column) {
+  var checkType = common.getCheckType(column);
+  return checkType === cellType.CellType.NUMBER;
+};
+
+exports.isNumberColumn = isNumberColumn;
+exports.isNumericColumn = isNumericColumn;