dtable-ui-component 0.3.2 → 0.3.4-alpha1

package/lib/RowExpandLinkFormatter/number-precision.js

@@ -0,0 +1,116 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+
+function strip(num) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 12;
+  return +parseFloat(num.toPrecision(precision));
+}
+
+function digitLength(num) {
+  // Get digit length of e
+  var eSplit = num.toString().split(/[eE]/);
+  var len = (eSplit[0].split('.')[1] || '').length - +(eSplit[1] || 0);
+  return len > 0 ? len : 0;
+}
+
+function float2Fixed(num) {
+  if (num.toString().indexOf('e') === -1) {
+    return Number(num.toString().replace('.', ''));
+  }
+
+  var dLen = digitLength(num);
+  return dLen > 0 ? strip(num * Math.pow(10, dLen)) : num;
+}
+
+function checkBoundary(num) {
+  if (_boundaryCheckingState) {
+    if (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) {
+      // eslint-disable-next-line no-console
+      console.warn("".concat(num, " is beyond boundary when transfer to integer, the results may not be accurate"));
+    }
+  }
+}
+
+function times(num1, num2) {
+  for (var _len = arguments.length, others = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    others[_key - 2] = arguments[_key];
+  }
+
+  if (others.length > 0) {
+    return times.apply(void 0, [times(num1, num2), others[0]].concat(_toConsumableArray(others.slice(1))));
+  }
+
+  var num1Changed = float2Fixed(num1);
+  var num2Changed = float2Fixed(num2);
+  var baseNum = digitLength(num1) + digitLength(num2);
+  var leftValue = num1Changed * num2Changed;
+  checkBoundary(leftValue);
+  return leftValue / Math.pow(10, baseNum);
+}
+
+function plus(num1, num2) {
+  for (var _len2 = arguments.length, others = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+    others[_key2 - 2] = arguments[_key2];
+  }
+
+  if (others.length > 0) {
+    return plus.apply(void 0, [plus(num1, num2), others[0]].concat(_toConsumableArray(others.slice(1))));
+  }
+
+  var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));
+  return (times(num1, baseNum) + times(num2, baseNum)) / baseNum;
+}
+
+function minus(num1, num2) {
+  for (var _len3 = arguments.length, others = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+    others[_key3 - 2] = arguments[_key3];
+  }
+
+  if (others.length > 0) {
+    return minus.apply(void 0, [minus(num1, num2), others[0]].concat(_toConsumableArray(others.slice(1))));
+  }
+
+  var baseNum = Math.pow(10, Math.max(digitLength(num1), digitLength(num2)));
+  return (times(num1, baseNum) - times(num2, baseNum)) / baseNum;
+}
+
+function divide(num1, num2) {
+  for (var _len4 = arguments.length, others = new Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
+    others[_key4 - 2] = arguments[_key4];
+  }
+
+  if (others.length > 0) {
+    return divide.apply(void 0, [divide(num1, num2), others[0]].concat(_toConsumableArray(others.slice(1))));
+  }
+
+  var num1Changed = float2Fixed(num1);
+  var num2Changed = float2Fixed(num2);
+  checkBoundary(num1Changed);
+  checkBoundary(num2Changed); // fix: Similar to 10 ** -4 is 0.00009999999999999999, strip correction
+
+  return times(num1Changed / num2Changed, strip(Math.pow(10, digitLength(num2) - digitLength(num1))));
+}
+
+function round(num, ratio) {
+  var base = Math.pow(10, ratio);
+  return divide(Math.round(times(num, base)), base);
+}
+
+var _boundaryCheckingState = true;
+
+function enableBoundaryChecking() {
+  var flag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  _boundaryCheckingState = flag;
+}
+
+export { strip, plus, minus, times, divide, round, digitLength, float2Fixed, enableBoundaryChecking };
+export default {
+  strip: strip,
+  plus: plus,
+  minus: minus,
+  times: times,
+  divide: divide,
+  round: round,
+  digitLength: digitLength,
+  float2Fixed: float2Fixed,
+  enableBoundaryChecking: enableBoundaryChecking
+};

package/lib/RowExpandLinkFormatter/utils.js

@@ -0,0 +1,58 @@
+import { CellType } from '../constants';
+export var isValidCellValue = function isValidCellValue(value) {
+  if (value === undefined) return false;
+  if (value === null) return false;
+  if (value === '') return false;
+  if (JSON.stringify(value) === '{}') return false;
+  if (JSON.stringify(value) === '[]') return false;
+  return true;
+};
+export var getFormulaArrayValue = function getFormulaArrayValue(value) {
+  var isFlat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!Array.isArray(value)) return [];
+  if (!isFlat) return getTwoDimensionArrayValue(value);
+  return value.map(function (item) {
+    if (Object.prototype.toString.call(item) !== '[object Object]') {
+      return item;
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(item, 'display_value')) return item;
+    var display_value = item.display_value;
+    if (!Array.isArray(display_value) || display_value.length === 0) return display_value;
+    return display_value.map(function (i) {
+      if (Object.prototype.toString.call(i) === '[object Object]') {
+        if (!Object.prototype.hasOwnProperty.call(i, 'display_value')) return i;
+        var _display_value = i.display_value;
+        return _display_value;
+      }
+
+      return i;
+    });
+  }).flat().filter(function (item) {
+    return isValidCellValue(item);
+  });
+};
+export var getTwoDimensionArrayValue = function getTwoDimensionArrayValue(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(function (item) {
+    if (Object.prototype.toString.call(item) !== '[object Object]') {
+      return item;
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(item, 'display_value')) return item;
+    var display_value = item.display_value;
+    if (!Array.isArray(display_value) || display_value.length === 0) return display_value;
+    return display_value.map(function (i) {
+      if (Object.prototype.toString.call(i) === '[object Object]') {
+        if (!Object.prototype.hasOwnProperty.call(i, 'display_value')) return i;
+        var _display_value2 = i.display_value;
+        return _display_value2;
+      }
+
+      return i;
+    });
+  });
+};
+export function isArrayFormalColumn(columnType) {
+  return [CellType.IMAGE, CellType.FILE, CellType.MULTIPLE_SELECT, CellType.COLLABORATOR].includes(columnType);
+}

package/lib/RowExpandLinkFormatter/value-display-utils.js

@@ -0,0 +1,401 @@
+import { CellType } from '../constants';
+import { isArrayFormalColumn } from './utils';
+import NP from './number-precision';
+import DateUtils from './date-utils';
+import { DURATION_FORMATS_MAP, DURATION_FORMATS, DURATION_ZERO_DISPLAY, DURATION_DECIMAL_DIGITS } from './column-data-constants';
+import { FORMULA_RESULT_TYPE } from './formula-constants';
+NP.enableBoundaryChecking(false);
+var DEFAULT_NUMBER_FORMAT = 'number';
+var COLLABORATOR_COLUMN_TYPES = [CellType.COLLABORATOR, CellType.CREATOR, CellType.LAST_MODIFIER];
+var DOWNLOAD_NAME_COLUMN_TYPES = [CellType.TEXT, CellType.NUMBER, CellType.DATE, CellType.COLLABORATOR, CellType.CREATOR, CellType.AUTO_NUMBER];
+var _separatorMap = {
+  'comma': ',',
+  'dot': '.',
+  'no': '',
+  'space': ' '
+};
+
+var _toThousands = function _toThousands(num, isCurrency, formatData) {
+  var _ref = formatData || {},
+      _ref$decimal = _ref.decimal,
+      decimal = _ref$decimal === void 0 ? 'dot' : _ref$decimal,
+      _ref$thousands = _ref.thousands,
+      thousands = _ref$thousands === void 0 ? 'no' : _ref$thousands,
+      _ref$precision = _ref.precision,
+      precision = _ref$precision === void 0 ? 2 : _ref$precision,
+      _ref$enable_precision = _ref.enable_precision,
+      enable_precision = _ref$enable_precision === void 0 ? false : _ref$enable_precision;
+
+  var decimalString = _separatorMap[decimal];
+  var thousandsString = _separatorMap[thousands];
+
+  if ((num + '').indexOf('e') > -1) {
+    if (num < 1 && num > -1) {
+      var _decimalDigits = enable_precision ? precision : 8;
+
+      return num.toFixed(_decimalDigits);
+    }
+
+    return num;
+  }
+
+  var decimalDigits = enable_precision ? precision : _getDecimalDigits(num);
+  var value = parseFloat(num.toFixed(decimalDigits));
+  var isMinus = value < 0;
+  var integer = Math.trunc(value); // format decimal value
+
+  var decimalValue = String(Math.abs(NP.minus(value, integer)).toFixed(decimalDigits)).slice(1);
+
+  if (isCurrency) {
+    if (!enable_precision) {
+      if (decimalValue.length === 2) {
+        decimalValue = decimalValue.padEnd(3, '0');
+      } else {
+        decimalValue = (decimalValue.substring(0, 3) || '.').padEnd(3, '0');
+      }
+    }
+  }
+
+  decimalValue = decimalValue.replace(/./, decimalString); // format integer value
+
+  var result = [],
+      counter = 0;
+  integer = Math.abs(integer).toString();
+
+  for (var i = integer.length - 1; i >= 0; i--) {
+    counter++;
+    result.unshift(integer[i]);
+
+    if (!(counter % 3) && i !== 0) {
+      result.unshift(thousandsString);
+    }
+  }
+
+  return (isMinus ? '-' : '') + result.join('') + decimalValue;
+};
+
+var _getDecimalDigits = function _getDecimalDigits(num) {
+  if (Number.isInteger(num)) {
+    return 0;
+  }
+
+  var valueArr = (num + '').split('.');
+  var digitsLength = valueArr[1] ? valueArr[1].length : 8;
+  return digitsLength > 8 ? 8 : digitsLength;
+};
+
+export var getNumberDisplayString = function getNumberDisplayString(value, formatData) {
+  // formatData: old version maybe 'null'
+  var type = Object.prototype.toString.call(value);
+
+  if (type !== '[object Number]') {
+    if (type === '[object String]' && value.startsWith('#')) {
+      return value;
+    }
+
+    return null;
+  }
+
+  if (isNaN(value) || value === Infinity || value === -Infinity) return value + '';
+
+  var _ref2 = formatData || {},
+      _ref2$format = _ref2.format,
+      format = _ref2$format === void 0 ? DEFAULT_NUMBER_FORMAT : _ref2$format;
+
+  switch (format) {
+    case 'number':
+      return _toThousands(value, false, formatData);
+
+    case 'percent':
+      {
+        return "".concat(_toThousands(Number.parseFloat((value * 100).toFixed(8)), false, formatData), "%");
+      }
+
+    case 'yuan':
+      return "\uFFE5".concat(_toThousands(value, true, formatData));
+
+    case 'dollar':
+      return "$".concat(_toThousands(value, true, formatData));
+
+    case 'euro':
+      return "\u20AC".concat(_toThousands(value, true, formatData));
+
+    case 'custom_currency':
+      {
+        return "".concat(formatData.currency_symbol || '').concat(_toThousands(value, true, formatData));
+      }
+
+    default:
+      return '' + value;
+  }
+};
+
+var getCollaboratorsName = function getCollaboratorsName(value, collaborators) {
+  if (Array.isArray(value) && value.length > 0 && Array.isArray(collaborators)) {
+    var collaboratorsName = [];
+    value.forEach(function (item) {
+      var collaborator = collaborators.find(function (c) {
+        return c.email === item;
+      });
+
+      if (collaborator) {
+        collaboratorsName.push(collaborator.name);
+      }
+    });
+    return collaboratorsName.join(',');
+  }
+
+  return '';
+};
+
+var getOptionName = function getOptionName(options, targetOptionID) {
+  if (!targetOptionID || !options || !Array.isArray(options)) return null;
+  var option = options.find(function (option) {
+    return option.id === targetOptionID;
+  });
+  return option ? option.name : null;
+};
+
+export var getMultipleOptionName = function getMultipleOptionName(options, cellVal) {
+  if (!cellVal || !options || !Array.isArray(options)) return null;
+  var selectedOptions = options.filter(function (option) {
+    return cellVal.includes(option.id);
+  });
+  if (selectedOptions.length === 0) return null;
+  return selectedOptions.map(function (option) {
+    return option.name;
+  }).join(', ');
+};
+
+var getLongtextDisplayString = function getLongtextDisplayString(value) {
+  var _ref3 = value || {},
+      text = _ref3.text;
+
+  if (!text) {
+    return null;
+  }
+
+  return text;
+};
+
+export var getCellDisplayValue = function getCellDisplayValue(record, column, collaborators) {
+  var type = column.type,
+      data = column.data,
+      key = column.key;
+  if (!DOWNLOAD_NAME_COLUMN_TYPES.includes(type)) return '';
+  var cellValue = record[key];
+
+  switch (type) {
+    case CellType.NUMBER:
+      {
+        return getNumberDisplayString(cellValue, data);
+      }
+
+    case CellType.DATE:
+      {
+        if (!cellValue || typeof cellValue !== 'string') return '';
+
+        var _ref4 = data || {},
+            format = _ref4.format;
+
+        return DateUtils.format(cellValue, format);
+      }
+
+    case CellType.COLLABORATOR:
+      {
+        if (!Array.isArray(cellValue)) return '';
+        return getCollaboratorsName(cellValue, collaborators);
+      }
+
+    case CellType.CREATOR:
+    case CellType.LAST_MODIFIER:
+      {
+        if (!cellValue) return '';
+        if (cellValue === 'anonymous') return cellValue;
+        return getCollaboratorsName([cellValue], collaborators);
+      }
+
+    case CellType.SINGLE_SELECT:
+      {
+        if (!data) return '';
+        var options = data.options;
+        return getOptionName(options, cellValue);
+      }
+
+    case CellType.MULTIPLE_SELECT:
+      {
+        if (!data) return '';
+
+        var _data$options = data.options,
+            _options = _data$options === void 0 ? [] : _data$options;
+
+        return getMultipleOptionName(_options, cellValue);
+      }
+
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        return getFormulaDisplayString(cellValue, data, collaborators);
+      }
+
+    case CellType.LONG_TEXT:
+      {
+        return getLongtextDisplayString(cellValue);
+      }
+
+    case CellType.DURATION:
+      {
+        return getDurationDisplayString(cellValue, data);
+      }
+
+    case CellType.CTIME:
+    case CellType.MTIME:
+      {
+        return DateUtils.format(cellValue.replace('T', ' ').replace('Z', ''), 'YYYY-MM-DD HH:MM:SS');
+      }
+
+    default:
+      {
+        return cellValue ? cellValue + '' : '';
+      }
+  }
+};
+
+var getFormulaDisplayString = function getFormulaDisplayString(cellValue, columnData, collaborators) {
+  if (!columnData) return null;
+  var result_type = columnData.result_type;
+
+  if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+    return getNumberDisplayString(cellValue, columnData);
+  }
+
+  if (result_type === FORMULA_RESULT_TYPE.DATE) {
+    var format = columnData.format;
+    return DateUtils.format(cellValue, format);
+  }
+
+  if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+    var array_type = columnData.array_type,
+        array_data = columnData.array_data;
+
+    if (!array_type) {
+      return null;
+    }
+
+    if (COLLABORATOR_COLUMN_TYPES.includes(array_type)) {
+      return cellValue;
+    }
+
+    if (isArrayFormalColumn(array_type) && Array.isArray(cellValue)) {
+      return cellValue.map(function (val) {
+        return getCellDisplayValue({
+          'FORMULA_ARRAY': val
+        }, {
+          type: 'array_type',
+          key: 'FORMULA_ARRAY',
+          data: array_data
+        }, collaborators);
+      }).join(', ');
+    }
+
+    return getCellDisplayValue({
+      'FORMULA_ARRAY': cellValue
+    }, {
+      type: 'array_type',
+      key: 'FORMULA_ARRAY',
+      data: array_data
+    }, collaborators);
+  }
+
+  if (Object.prototype.toString.call(cellValue) === '[object Boolean]') {
+    return cellValue + '';
+  }
+
+  return cellValue;
+};
+
+function getMathRoundedDuration(num, duration_format) {
+  var decimalDigits = DURATION_DECIMAL_DIGITS[duration_format];
+
+  if (decimalDigits < 1) {
+    return num;
+  }
+
+  var ratio = Math.pow(10, decimalDigits);
+  return Math.round(num * ratio) / ratio;
+}
+
+function getDurationDecimalSuffix(duration_format, decimal) {
+  if (duration_format === DURATION_FORMATS_MAP.H_MM_SS_S) {
+    return decimal === 0 ? '.0' : '';
+  } else if (duration_format === DURATION_FORMATS_MAP.H_MM_SS_SS) {
+    if (decimal === 0) {
+      return '.00';
+    } else if (decimal < 10) {
+      return '0';
+    }
+  } else if (duration_format === DURATION_FORMATS_MAP.H_MM_SS_SSS) {
+    if (decimal === 0) {
+      return '.000';
+    } else if (decimal < 10) {
+      return '00';
+    } else if (decimal < 100) {
+      return '0';
+    }
+  }
+
+  return '';
+}
+
+export var getDurationDisplayString = function getDurationDisplayString(value, data) {
+  if (!value && value !== 0) return '';
+
+  var _ref5 = data || {},
+      duration_format = _ref5.duration_format;
+
+  duration_format = duration_format || DURATION_FORMATS_MAP.H_MM;
+
+  if (DURATION_FORMATS.findIndex(function (format) {
+    return format.type === duration_format;
+  }) < 0) {
+    return '';
+  }
+
+  if (value === 0) {
+    return DURATION_ZERO_DISPLAY[duration_format];
+  }
+
+  var includeDecimal = duration_format.indexOf('.') > -1;
+  var positiveValue = Math.abs(value);
+
+  if (!includeDecimal) {
+    positiveValue = Math.round(positiveValue);
+  }
+
+  positiveValue = getMathRoundedDuration(positiveValue, duration_format);
+  var decimalParts = (positiveValue + '').split('.');
+  var decimalPartsLen = decimalParts.length;
+  var decimal = 0;
+
+  if (decimalPartsLen > 1) {
+    decimal = decimalParts[decimalPartsLen - 1];
+    decimal = decimal ? decimal - 0 : 0;
+  }
+
+  var decimalDigits = DURATION_DECIMAL_DIGITS[duration_format];
+  var decimalSuffix = getDurationDecimalSuffix(duration_format, decimal);
+  var displayString = value < 0 ? '-' : '';
+  var hours = parseInt(positiveValue / 3600);
+  var minutes = parseInt((positiveValue - hours * 3600) / 60);
+
+  if (duration_format === DURATION_FORMATS_MAP.H_MM) {
+    displayString += "".concat(hours, ":").concat(minutes > 9 ? minutes : '0' + 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;
+};

package/lib/SimpleLongTextFormatter/index.js

@@ -3,7 +3,7 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
-import cn from 'astro-classname';
+import classnames from 'classnames';
 import getPreviewContent from './normalize-long-text-value';
 import LongTextPreview from './widgets/LongTextPreview';
 import ModalPortal from '../ModalPortal';
@@ -133,7 +133,7 @@ var SimpleLongTextFormatter = /*#__PURE__*/function (_React$Component) {
 
       var isPreview = this.state.isPreview;
       var containerClassName = this.props.containerClassName;
-      var className = cn('dtable-ui cell-formatter-container long-text-formatter', containerClassName);
+      var className = classnames('dtable-ui cell-formatter-container long-text-formatter', containerClassName);
       var value = this.translateValue();
       return /*#__PURE__*/React.createElement("div", {
         className: className,

package/lib/SingleSelectFormatter/index.js

@@ -3,7 +3,7 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
-import cn from 'astro-classname';
+import classnames from 'classnames';
 import SelectItem from '../SelectItem';
 import './index.css';
 
@@ -49,7 +49,7 @@ var SingleSelectFormatter = /*#__PURE__*/function (_React$PureComponent) {
       var _this$props2 = this.props,
           containerClassName = _this$props2.containerClassName,
           value = _this$props2.value;
-      var classname = cn('dtable-ui cell-formatter-container single-select-formatter', containerClassName);
+      var classname = classnames('dtable-ui cell-formatter-container single-select-formatter', containerClassName);
       return /*#__PURE__*/React.createElement("div", {
         className: classname
       }, value ? this.getOption() : '');

package/lib/TextFormatter/index.js

@@ -3,7 +3,7 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
-import cn from 'astro-classname';
+import classnames from 'classnames';
 import './index.css';
 
 var TextFormatter = /*#__PURE__*/function (_React$Component) {
@@ -43,7 +43,7 @@ var TextFormatter = /*#__PURE__*/function (_React$Component) {
       var _this$props = this.props,
           containerClassName = _this$props.containerClassName,
           value = _this$props.value;
-      var classname = cn('dtable-ui cell-formatter-container text-formatter', containerClassName);
+      var classname = classnames('dtable-ui cell-formatter-container text-formatter', containerClassName);
       var formattedValue = this.getFormattedValue(value);
       return /*#__PURE__*/React.createElement("div", {
         className: classname,

package/lib/UrlFormatter/index.js

@@ -3,7 +3,7 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
-import cn from 'astro-classname';
+import classnames from 'classnames';
 import './index.css';
 
 var UrlFormatter = /*#__PURE__*/function (_React$Component) {
@@ -23,7 +23,7 @@ var UrlFormatter = /*#__PURE__*/function (_React$Component) {
       var _this$props = this.props,
           containerClassName = _this$props.containerClassName,
           value = _this$props.value;
-      var classname = cn('dtable-ui cell-formatter-container url-formatter', containerClassName);
+      var classname = classnames('dtable-ui cell-formatter-container url-formatter', containerClassName);
       return /*#__PURE__*/React.createElement("div", {
         className: classname
       }, value);

package/lib/common/delete-tip.css

@@ -0,0 +1,16 @@
+.dtable-tip.tip-container {
+  display: flex;
+  flex-direction: column;
+  width: 232px;
+  padding: 16px;
+  background: #fff;
+  border-radius: 5px;
+  border: 1px solid #ddd;
+  box-shadow: 0 2px 8px 1px rgba(0, 0, 0, 0.2);
+  position: fixed;
+  z-index: 10000;
+}
+
+.dtable-tip.tip-container b {
+  line-height: 1.5;
+}