amis 2.1.1-beta.2 → 2.2.0

package/lib/index.d.ts

@@ -140,7 +140,7 @@ import './renderers/WebComponent';
 import './renderers/GridNav';
 import './renderers/TooltipWrapper';
 import './renderers/Tag';
-import './renderers/Table-v2/index';
+import './renderers/Table2/index';
 import './compat';
 import './schemaExtend';
 export * from './renderers/Form/IconPickerIcons';

package/lib/index.js

@@ -1,5 +1,5 @@
 /**
- * amis v2.1.1-beta.2
+ * amis v2.2.0
  * Copyright 2018-2022 baidu
  */
 
@@ -142,7 +142,7 @@ require('./renderers/WebComponent.js');
 require('./renderers/GridNav.js');
 require('./renderers/TooltipWrapper.js');
 require('./renderers/Tag.js');
-require('./renderers/Table-v2/index.js');
+require('./renderers/Table2/index.js');
 require('./compat.js');
 require('./schemaExtend.js');
 var IconPickerIcons = require('./renderers/Form/IconPickerIcons.js');

package/lib/node_modules/@babel/runtime/helpers/classCallCheck.js

@@ -0,0 +1,29 @@
+/**
+ * amis v2.2.0
+ * Copyright 2018-2022 baidu
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var classCallCheck = require('../../../../_virtual/classCallCheck.js');
+
+var hasRequiredClassCallCheck;
+
+function requireClassCallCheck () {
+	if (hasRequiredClassCallCheck) return classCallCheck.classCallCheck.exports;
+	hasRequiredClassCallCheck = 1;
+	(function (module) {
+		function _classCallCheck(instance, Constructor) {
+		  if (!(instance instanceof Constructor)) {
+		    throw new TypeError("Cannot call a class as a function");
+		  }
+		}
+
+		module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (classCallCheck.classCallCheck));
+	return classCallCheck.classCallCheck.exports;
+}
+
+exports.__require = requireClassCallCheck;

package/lib/node_modules/@babel/runtime/helpers/createClass.js

@@ -0,0 +1,42 @@
+/**
+ * amis v2.2.0
+ * Copyright 2018-2022 baidu
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createClass = require('../../../../_virtual/createClass.js');
+
+var hasRequiredCreateClass;
+
+function requireCreateClass () {
+	if (hasRequiredCreateClass) return createClass.createClass.exports;
+	hasRequiredCreateClass = 1;
+	(function (module) {
+		function _defineProperties(target, props) {
+		  for (var i = 0; i < props.length; i++) {
+		    var descriptor = props[i];
+		    descriptor.enumerable = descriptor.enumerable || false;
+		    descriptor.configurable = true;
+		    if ("value" in descriptor) descriptor.writable = true;
+		    Object.defineProperty(target, descriptor.key, descriptor);
+		  }
+		}
+
+		function _createClass(Constructor, protoProps, staticProps) {
+		  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		  if (staticProps) _defineProperties(Constructor, staticProps);
+		  Object.defineProperty(Constructor, "prototype", {
+		    writable: false
+		  });
+		  return Constructor;
+		}
+
+		module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (createClass.createClass));
+	return createClass.createClass.exports;
+}
+
+exports.__require = requireCreateClass;

package/lib/node_modules/@babel/runtime/helpers/interopRequireDefault.js

@@ -0,0 +1,18 @@
+/**
+ * amis v2.2.0
+ * Copyright 2018-2022 baidu
+ */
+
+'use strict';
+
+var interopRequireDefault = require('../../../../_virtual/interopRequireDefault.js');
+
+(function (module) {
+	function _interopRequireDefault(obj) {
+	  return obj && obj.__esModule ? obj : {
+	    "default": obj
+	  };
+	}
+
+	module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (interopRequireDefault.interopRequireDefault));

package/lib/node_modules/rc-input-number/lib/utils/MiniDecimal.js

@@ -0,0 +1,349 @@
+/**
+ * amis v2.2.0
+ * Copyright 2018-2022 baidu
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var MiniDecimal = require('../../../../_virtual/MiniDecimal.js');
+require('../../../@babel/runtime/helpers/interopRequireDefault.js');
+var classCallCheck = require('../../../@babel/runtime/helpers/classCallCheck.js');
+var createClass = require('../../../@babel/runtime/helpers/createClass.js');
+var numberUtil = require('./numberUtil.js');
+var supportUtil = require('./supportUtil.js');
+var interopRequireDefault = require('../../../../_virtual/interopRequireDefault.js');
+
+var _interopRequireDefault = interopRequireDefault.interopRequireDefault.exports;
+
+Object.defineProperty(MiniDecimal.__exports, "__esModule", {
+  value: true
+});
+MiniDecimal.__exports.NumberDecimal = MiniDecimal.__exports.BigIntDecimal = void 0;
+MiniDecimal.__exports.default = getMiniDecimal;
+var toFixed_1 = MiniDecimal.__exports.toFixed = toFixed;
+
+var _classCallCheck2 = _interopRequireDefault(classCallCheck.__require());
+
+var _createClass2 = _interopRequireDefault(createClass.__require());
+
+var _numberUtil = numberUtil.__require();
+
+var _supportUtil = supportUtil.__require();
+
+/* eslint-disable max-classes-per-file */
+
+/**
+ * We can remove this when IE not support anymore
+ */
+var NumberDecimal = /*#__PURE__*/function () {
+  function NumberDecimal(value) {
+    (0, _classCallCheck2.default)(this, NumberDecimal);
+    this.origin = '';
+    this.number = void 0;
+    this.empty = void 0;
+
+    if (!value && value !== 0 || !String(value).trim()) {
+      this.empty = true;
+      return;
+    }
+
+    this.origin = String(value);
+    this.number = Number(value);
+  }
+
+  (0, _createClass2.default)(NumberDecimal, [{
+    key: "negate",
+    value: function negate() {
+      return new NumberDecimal(-this.toNumber());
+    }
+  }, {
+    key: "add",
+    value: function add(value) {
+      if (this.isInvalidate()) {
+        return new NumberDecimal(value);
+      }
+
+      var target = Number(value);
+
+      if (Number.isNaN(target)) {
+        return this;
+      }
+
+      var number = this.number + target; // [Legacy] Back to safe integer
+
+      if (number > Number.MAX_SAFE_INTEGER) {
+        return new NumberDecimal(Number.MAX_SAFE_INTEGER);
+      }
+
+      if (number < Number.MIN_SAFE_INTEGER) {
+        return new NumberDecimal(Number.MIN_SAFE_INTEGER);
+      }
+
+      var maxPrecision = Math.max((0, _numberUtil.getNumberPrecision)(this.number), (0, _numberUtil.getNumberPrecision)(target));
+      return new NumberDecimal(number.toFixed(maxPrecision));
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.empty;
+    }
+  }, {
+    key: "isNaN",
+    value: function isNaN() {
+      return Number.isNaN(this.number);
+    }
+  }, {
+    key: "isInvalidate",
+    value: function isInvalidate() {
+      return this.isEmpty() || this.isNaN();
+    }
+  }, {
+    key: "equals",
+    value: function equals(target) {
+      return this.toNumber() === (target === null || target === void 0 ? void 0 : target.toNumber());
+    }
+  }, {
+    key: "lessEquals",
+    value: function lessEquals(target) {
+      return this.add(target.negate().toString()).toNumber() <= 0;
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      return this.number;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+      if (!safe) {
+        return this.origin;
+      }
+
+      if (this.isInvalidate()) {
+        return '';
+      }
+
+      return (0, _numberUtil.num2str)(this.number);
+    }
+  }]);
+  return NumberDecimal;
+}();
+
+MiniDecimal.__exports.NumberDecimal = NumberDecimal;
+
+var BigIntDecimal = /*#__PURE__*/function () {
+  /** BigInt will convert `0009` to `9`. We need record the len of decimal */
+  function BigIntDecimal(value) {
+    (0, _classCallCheck2.default)(this, BigIntDecimal);
+    this.origin = '';
+    this.negative = void 0;
+    this.integer = void 0;
+    this.decimal = void 0;
+    this.decimalLen = void 0;
+    this.empty = void 0;
+    this.nan = void 0;
+
+    if (!value && value !== 0 || !String(value).trim()) {
+      this.empty = true;
+      return;
+    }
+
+    this.origin = String(value); // Act like Number convert
+
+    if (value === '-') {
+      this.nan = true;
+      return;
+    }
+
+    var mergedValue = value; // We need convert back to Number since it require `toFixed` to handle this
+
+    if ((0, _numberUtil.isE)(mergedValue)) {
+      mergedValue = Number(mergedValue);
+    }
+
+    mergedValue = typeof mergedValue === 'string' ? mergedValue : (0, _numberUtil.num2str)(mergedValue);
+
+    if ((0, _numberUtil.validateNumber)(mergedValue)) {
+      var trimRet = (0, _numberUtil.trimNumber)(mergedValue);
+      this.negative = trimRet.negative;
+      var numbers = trimRet.trimStr.split('.');
+      this.integer = BigInt(numbers[0]);
+      var decimalStr = numbers[1] || '0';
+      this.decimal = BigInt(decimalStr);
+      this.decimalLen = decimalStr.length;
+    } else {
+      this.nan = true;
+    }
+  }
+
+  (0, _createClass2.default)(BigIntDecimal, [{
+    key: "getMark",
+    value: function getMark() {
+      return this.negative ? '-' : '';
+    }
+  }, {
+    key: "getIntegerStr",
+    value: function getIntegerStr() {
+      return this.integer.toString();
+    }
+  }, {
+    key: "getDecimalStr",
+    value: function getDecimalStr() {
+      return this.decimal.toString().padStart(this.decimalLen, '0');
+    }
+    /**
+     * Align BigIntDecimal with same decimal length. e.g. 12.3 + 5 = 1230000
+     * This is used for add function only.
+     */
+
+  }, {
+    key: "alignDecimal",
+    value: function alignDecimal(decimalLength) {
+      var str = "".concat(this.getMark()).concat(this.getIntegerStr()).concat(this.getDecimalStr().padEnd(decimalLength, '0'));
+      return BigInt(str);
+    }
+  }, {
+    key: "negate",
+    value: function negate() {
+      var clone = new BigIntDecimal(this.toString());
+      clone.negative = !clone.negative;
+      return clone;
+    }
+  }, {
+    key: "add",
+    value: function add(value) {
+      if (this.isInvalidate()) {
+        return new BigIntDecimal(value);
+      }
+
+      var offset = new BigIntDecimal(value);
+
+      if (offset.isInvalidate()) {
+        return this;
+      }
+
+      var maxDecimalLength = Math.max(this.getDecimalStr().length, offset.getDecimalStr().length);
+      var myAlignedDecimal = this.alignDecimal(maxDecimalLength);
+      var offsetAlignedDecimal = offset.alignDecimal(maxDecimalLength);
+      var valueStr = (myAlignedDecimal + offsetAlignedDecimal).toString(); // We need fill string length back to `maxDecimalLength` to avoid parser failed
+
+      var _trimNumber = (0, _numberUtil.trimNumber)(valueStr),
+          negativeStr = _trimNumber.negativeStr,
+          trimStr = _trimNumber.trimStr;
+
+      var hydrateValueStr = "".concat(negativeStr).concat(trimStr.padStart(maxDecimalLength + 1, '0'));
+      return new BigIntDecimal("".concat(hydrateValueStr.slice(0, -maxDecimalLength), ".").concat(hydrateValueStr.slice(-maxDecimalLength)));
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.empty;
+    }
+  }, {
+    key: "isNaN",
+    value: function isNaN() {
+      return this.nan;
+    }
+  }, {
+    key: "isInvalidate",
+    value: function isInvalidate() {
+      return this.isEmpty() || this.isNaN();
+    }
+  }, {
+    key: "equals",
+    value: function equals(target) {
+      return this.toString() === (target === null || target === void 0 ? void 0 : target.toString());
+    }
+  }, {
+    key: "lessEquals",
+    value: function lessEquals(target) {
+      return this.add(target.negate().toString()).toNumber() <= 0;
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      if (this.isNaN()) {
+        return NaN;
+      }
+
+      return Number(this.toString());
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+      if (!safe) {
+        return this.origin;
+      }
+
+      if (this.isInvalidate()) {
+        return '';
+      }
+
+      return (0, _numberUtil.trimNumber)("".concat(this.getMark()).concat(this.getIntegerStr(), ".").concat(this.getDecimalStr())).fullStr;
+    }
+  }]);
+  return BigIntDecimal;
+}();
+
+MiniDecimal.__exports.BigIntDecimal = BigIntDecimal;
+
+function getMiniDecimal(value) {
+  // We use BigInt here.
+  // Will fallback to Number if not support.
+  if ((0, _supportUtil.supportBigInt)()) {
+    return new BigIntDecimal(value);
+  }
+
+  return new NumberDecimal(value);
+}
+/**
+ * Align the logic of toFixed to around like 1.5 => 2.
+ * If set `cutOnly`, will just remove the over decimal part.
+ */
+
+
+function toFixed(numStr, separatorStr, precision) {
+  var cutOnly = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+  if (numStr === '') {
+    return '';
+  }
+
+  var _trimNumber2 = (0, _numberUtil.trimNumber)(numStr),
+      negativeStr = _trimNumber2.negativeStr,
+      integerStr = _trimNumber2.integerStr,
+      decimalStr = _trimNumber2.decimalStr;
+
+  var precisionDecimalStr = "".concat(separatorStr).concat(decimalStr);
+  var numberWithoutDecimal = "".concat(negativeStr).concat(integerStr);
+
+  if (precision >= 0) {
+    // We will get last + 1 number to check if need advanced number
+    var advancedNum = Number(decimalStr[precision]);
+
+    if (advancedNum >= 5 && !cutOnly) {
+      var advancedDecimal = getMiniDecimal(numStr).add("".concat(negativeStr, "0.").concat('0'.repeat(precision)).concat(10 - advancedNum));
+      return toFixed(advancedDecimal.toString(), separatorStr, precision, cutOnly);
+    }
+
+    if (precision === 0) {
+      return numberWithoutDecimal;
+    }
+
+    return "".concat(numberWithoutDecimal).concat(separatorStr).concat(decimalStr.padEnd(precision, '0').slice(0, precision));
+  }
+
+  if (precisionDecimalStr === '.0') {
+    return numberWithoutDecimal;
+  }
+
+  return "".concat(numberWithoutDecimal).concat(precisionDecimalStr);
+}
+
+exports.toFixed = toFixed_1;

package/lib/node_modules/rc-input-number/lib/utils/numberUtil.js

@@ -0,0 +1,150 @@
+/**
+ * amis v2.2.0
+ * Copyright 2018-2022 baidu
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var numberUtil = require('../../../../_virtual/numberUtil.js');
+var supportUtil = require('./supportUtil.js');
+
+var hasRequiredNumberUtil;
+
+function requireNumberUtil () {
+	if (hasRequiredNumberUtil) return numberUtil.__exports;
+	hasRequiredNumberUtil = 1;
+
+	Object.defineProperty(numberUtil.__exports, "__esModule", {
+	  value: true
+	});
+	numberUtil.__exports.getDecupleSteps = getDecupleSteps;
+	numberUtil.__exports.getNumberPrecision = getNumberPrecision;
+	numberUtil.__exports.isE = isE;
+	numberUtil.__exports.num2str = num2str;
+	numberUtil.__exports.trimNumber = trimNumber;
+	numberUtil.__exports.validateNumber = validateNumber;
+
+	var _supportUtil = supportUtil.__require();
+
+	/**
+	 * Format string number to readable number
+	 */
+	function trimNumber(numStr) {
+	  var str = numStr.trim();
+	  var negative = str.startsWith('-');
+
+	  if (negative) {
+	    str = str.slice(1);
+	  }
+
+	  str = str // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`
+	  .replace(/(\.\d*[^0])0*$/, '$1') // Remove useless decimal. `1.` => `1`
+	  .replace(/\.0*$/, '') // Remove integer 0. `0001` => `1`, 000.1' => `.1`
+	  .replace(/^0+/, '');
+
+	  if (str.startsWith('.')) {
+	    str = "0".concat(str);
+	  }
+
+	  var trimStr = str || '0';
+	  var splitNumber = trimStr.split('.');
+	  var integerStr = splitNumber[0] || '0';
+	  var decimalStr = splitNumber[1] || '0';
+
+	  if (integerStr === '0' && decimalStr === '0') {
+	    negative = false;
+	  }
+
+	  var negativeStr = negative ? '-' : '';
+	  return {
+	    negative: negative,
+	    negativeStr: negativeStr,
+	    trimStr: trimStr,
+	    integerStr: integerStr,
+	    decimalStr: decimalStr,
+	    fullStr: "".concat(negativeStr).concat(trimStr)
+	  };
+	}
+
+	function isE(number) {
+	  var str = String(number);
+	  return !Number.isNaN(Number(str)) && str.includes('e');
+	}
+	/**
+	 * [Legacy] Convert 1e-9 to 0.000000001.
+	 * This may lose some precision if user really want 1e-9.
+	 */
+
+
+	function getNumberPrecision(number) {
+	  var numStr = String(number);
+
+	  if (isE(number)) {
+	    var precision = Number(numStr.slice(numStr.indexOf('e-') + 2));
+	    var decimalMatch = numStr.match(/\.(\d+)/);
+
+	    if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) {
+	      precision += decimalMatch[1].length;
+	    }
+
+	    return precision;
+	  }
+
+	  return numStr.includes('.') && validateNumber(numStr) ? numStr.length - numStr.indexOf('.') - 1 : 0;
+	}
+	/**
+	 * Convert number (includes scientific notation) to -xxx.yyy format
+	 */
+
+
+	function num2str(number) {
+	  var numStr = String(number);
+
+	  if (isE(number)) {
+	    if (number > Number.MAX_SAFE_INTEGER) {
+	      return String((0, _supportUtil.supportBigInt)() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
+	    }
+
+	    if (number < Number.MIN_SAFE_INTEGER) {
+	      return String((0, _supportUtil.supportBigInt)() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
+	    }
+
+	    numStr = number.toFixed(getNumberPrecision(numStr));
+	  }
+
+	  return trimNumber(numStr).fullStr;
+	}
+
+	function validateNumber(num) {
+	  if (typeof num === 'number') {
+	    return !Number.isNaN(num);
+	  } // Empty
+
+
+	  if (!num) {
+	    return false;
+	  }
+
+	  return (// Normal type: 11.28
+	    /^\s*-?\d+(\.\d+)?\s*$/.test(num) || // Pre-number: 1.
+	    /^\s*-?\d+\.\s*$/.test(num) || // Post-number: .1
+	    /^\s*-?\.\d+\s*$/.test(num)
+	  );
+	}
+
+	function getDecupleSteps(step) {
+	  var stepStr = typeof step === 'number' ? num2str(step) : trimNumber(step).fullStr;
+	  var hasPoint = stepStr.includes('.');
+
+	  if (!hasPoint) {
+	    return step + '0';
+	  }
+
+	  return trimNumber(stepStr.replace(/(\d)\.(\d)/g, '$1$2.')).fullStr;
+	}
+	return numberUtil.__exports;
+}
+
+exports.__require = requireNumberUtil;

package/lib/node_modules/rc-input-number/lib/utils/supportUtil.js

@@ -0,0 +1,29 @@
+/**
+ * amis v2.2.0
+ * Copyright 2018-2022 baidu
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var supportUtil = require('../../../../_virtual/supportUtil.js');
+
+var hasRequiredSupportUtil;
+
+function requireSupportUtil () {
+	if (hasRequiredSupportUtil) return supportUtil.__exports;
+	hasRequiredSupportUtil = 1;
+
+	Object.defineProperty(supportUtil.__exports, "__esModule", {
+	  value: true
+	});
+	supportUtil.__exports.supportBigInt = supportBigInt;
+
+	function supportBigInt() {
+	  return typeof BigInt === 'function';
+	}
+	return supportUtil.__exports;
+}
+
+exports.__require = requireSupportUtil;

package/lib/preset.js

@@ -1,5 +1,5 @@
 /**
- * amis v2.1.1-beta.2
+ * amis v2.2.0
  * Copyright 2018-2022 baidu
  */