You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1759 lines
68 KiB
1759 lines
68 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[51370],{
|
|
|
|
/***/ 92287:
|
|
/*!*****************************************************************!*\
|
|
!*** ./node_modules/@ant-design/icons-svg/es/asn/UpOutlined.js ***!
|
|
\*****************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__) {
|
|
|
|
// This icon file is generated automatically.
|
|
var UpOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M890.5 755.3L537.9 269.2c-12.8-17.6-39-17.6-51.7 0L133.5 755.3A8 8 0 00140 768h75c5.1 0 9.9-2.5 12.9-6.6L512 369.8l284.1 391.6c3 4.1 7.8 6.6 12.9 6.6h75c6.5 0 10.3-7.4 6.5-12.7z" } }] }, "name": "up", "theme": "outlined" };
|
|
/* harmony default export */ __webpack_exports__["Z"] = (UpOutlined);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5467:
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/antd/es/_util/getDataOrAriaProps.js ***!
|
|
\**********************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
/* harmony export */ "Z": function() { return /* binding */ getDataOrAriaProps; }
|
|
/* harmony export */ });
|
|
function getDataOrAriaProps(props) {
|
|
return Object.keys(props).reduce(function (prev, key) {
|
|
if ((key.startsWith('data-') || key.startsWith('aria-') || key === 'role') && !key.startsWith('data-__')) {
|
|
prev[key] = props[key];
|
|
}
|
|
return prev;
|
|
}, {});
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 87799:
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/antd/es/input-number/index.js + 9 modules ***!
|
|
\****************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ input_number; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/DownOutlined.js
|
|
var DownOutlined = __webpack_require__(13622);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons-svg/es/asn/UpOutlined.js
|
|
var asn_UpOutlined = __webpack_require__(92287);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/components/AntdIcon.js + 3 modules
|
|
var AntdIcon = __webpack_require__(93771);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/UpOutlined.js
|
|
|
|
// GENERATE BY ./scripts/generate.ts
|
|
// DON NOT EDIT IT MANUALLY
|
|
|
|
|
|
|
|
var UpOutlined = function UpOutlined(props, ref) {
|
|
return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
ref: ref,
|
|
icon: asn_UpOutlined/* default */.Z
|
|
}));
|
|
};
|
|
UpOutlined.displayName = 'UpOutlined';
|
|
/* harmony default export */ var icons_UpOutlined = (/*#__PURE__*/react.forwardRef(UpOutlined));
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/KeyCode.js
|
|
var KeyCode = __webpack_require__(15105);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
var useLayoutEffect = __webpack_require__(8410);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/ref.js
|
|
var es_ref = __webpack_require__(42550);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
|
|
var classCallCheck = __webpack_require__(15671);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
var createClass = __webpack_require__(43144);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/utils/supportUtil.js
|
|
function supportBigInt() {
|
|
return typeof BigInt === 'function';
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/utils/numberUtil.js
|
|
|
|
/**
|
|
* 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(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
|
|
}
|
|
if (number < Number.MIN_SAFE_INTEGER) {
|
|
return String(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;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/utils/MiniDecimal.js
|
|
|
|
|
|
/* eslint-disable max-classes-per-file */
|
|
|
|
|
|
/**
|
|
* We can remove this when IE not support anymore
|
|
*/
|
|
var NumberDecimal = /*#__PURE__*/function () {
|
|
function NumberDecimal(value) {
|
|
(0,classCallCheck/* default */.Z)(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,createClass/* default */.Z)(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(getNumberPrecision(this.number), 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 num2str(this.number);
|
|
}
|
|
}]);
|
|
return NumberDecimal;
|
|
}();
|
|
var BigIntDecimal = /*#__PURE__*/function () {
|
|
/** BigInt will convert `0009` to `9`. We need record the len of decimal */
|
|
|
|
function BigIntDecimal(value) {
|
|
(0,classCallCheck/* default */.Z)(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 (isE(mergedValue)) {
|
|
mergedValue = Number(mergedValue);
|
|
}
|
|
mergedValue = typeof mergedValue === 'string' ? mergedValue : num2str(mergedValue);
|
|
if (validateNumber(mergedValue)) {
|
|
var trimRet = 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,createClass/* default */.Z)(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 = 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 trimNumber("".concat(this.getMark()).concat(this.getIntegerStr(), ".").concat(this.getDecimalStr())).fullStr;
|
|
}
|
|
}]);
|
|
return BigIntDecimal;
|
|
}();
|
|
function getMiniDecimal(value) {
|
|
// We use BigInt here.
|
|
// Will fallback to Number if not support.
|
|
if (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 = 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);
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/isMobile.js
|
|
var isMobile = __webpack_require__(53334);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/StepHandler.js
|
|
|
|
|
|
/* eslint-disable react/no-unknown-property */
|
|
|
|
|
|
|
|
/**
|
|
* When click and hold on a button - the speed of auto changing the value.
|
|
*/
|
|
var STEP_INTERVAL = 200;
|
|
/**
|
|
* When click and hold on a button - the delay before auto changing the value.
|
|
*/
|
|
var STEP_DELAY = 600;
|
|
function StepHandler(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
upNode = _ref.upNode,
|
|
downNode = _ref.downNode,
|
|
upDisabled = _ref.upDisabled,
|
|
downDisabled = _ref.downDisabled,
|
|
onStep = _ref.onStep;
|
|
// ======================== Step ========================
|
|
var stepTimeoutRef = react.useRef();
|
|
var onStepRef = react.useRef();
|
|
onStepRef.current = onStep;
|
|
// We will interval update step when hold mouse down
|
|
var onStepMouseDown = function onStepMouseDown(e, up) {
|
|
e.preventDefault();
|
|
onStepRef.current(up);
|
|
// Loop step for interval
|
|
function loopStep() {
|
|
onStepRef.current(up);
|
|
stepTimeoutRef.current = setTimeout(loopStep, STEP_INTERVAL);
|
|
}
|
|
// First time press will wait some time to trigger loop step update
|
|
stepTimeoutRef.current = setTimeout(loopStep, STEP_DELAY);
|
|
};
|
|
var onStopStep = function onStopStep() {
|
|
clearTimeout(stepTimeoutRef.current);
|
|
};
|
|
react.useEffect(function () {
|
|
return onStopStep;
|
|
}, []);
|
|
// ======================= Render =======================
|
|
if ((0,isMobile/* default */.Z)()) {
|
|
return null;
|
|
}
|
|
var handlerClassName = "".concat(prefixCls, "-handler");
|
|
var upClassName = classnames_default()(handlerClassName, "".concat(handlerClassName, "-up"), (0,defineProperty/* default */.Z)({}, "".concat(handlerClassName, "-up-disabled"), upDisabled));
|
|
var downClassName = classnames_default()(handlerClassName, "".concat(handlerClassName, "-down"), (0,defineProperty/* default */.Z)({}, "".concat(handlerClassName, "-down-disabled"), downDisabled));
|
|
var sharedHandlerProps = {
|
|
unselectable: 'on',
|
|
role: 'button',
|
|
onMouseUp: onStopStep,
|
|
onMouseLeave: onStopStep
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(handlerClassName, "-wrap")
|
|
}, /*#__PURE__*/react.createElement("span", (0,esm_extends/* default */.Z)({}, sharedHandlerProps, {
|
|
onMouseDown: function onMouseDown(e) {
|
|
onStepMouseDown(e, true);
|
|
},
|
|
"aria-label": "Increase Value",
|
|
"aria-disabled": upDisabled,
|
|
className: upClassName
|
|
}), upNode || /*#__PURE__*/react.createElement("span", {
|
|
unselectable: "on",
|
|
className: "".concat(prefixCls, "-handler-up-inner")
|
|
})), /*#__PURE__*/react.createElement("span", (0,esm_extends/* default */.Z)({}, sharedHandlerProps, {
|
|
onMouseDown: function onMouseDown(e) {
|
|
onStepMouseDown(e, false);
|
|
},
|
|
"aria-label": "Decrease Value",
|
|
"aria-disabled": downDisabled,
|
|
className: downClassName
|
|
}), downNode || /*#__PURE__*/react.createElement("span", {
|
|
unselectable: "on",
|
|
className: "".concat(prefixCls, "-handler-down-inner")
|
|
})));
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/warning.js
|
|
var warning = __webpack_require__(80334);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/hooks/useCursor.js
|
|
|
|
|
|
/**
|
|
* Keep input cursor in the correct position if possible.
|
|
* Is this necessary since we have `formatter` which may mass the content?
|
|
*/
|
|
function useCursor(input, focused) {
|
|
var selectionRef = (0,react.useRef)(null);
|
|
function recordCursor() {
|
|
// Record position
|
|
try {
|
|
var start = input.selectionStart,
|
|
end = input.selectionEnd,
|
|
value = input.value;
|
|
var beforeTxt = value.substring(0, start);
|
|
var afterTxt = value.substring(end);
|
|
selectionRef.current = {
|
|
start: start,
|
|
end: end,
|
|
value: value,
|
|
beforeTxt: beforeTxt,
|
|
afterTxt: afterTxt
|
|
};
|
|
} catch (e) {
|
|
// Fix error in Chrome:
|
|
// Failed to read the 'selectionStart' property from 'HTMLInputElement'
|
|
// http://stackoverflow.com/q/21177489/3040605
|
|
}
|
|
}
|
|
/**
|
|
* Restore logic:
|
|
* 1. back string same
|
|
* 2. start string same
|
|
*/
|
|
function restoreCursor() {
|
|
if (input && selectionRef.current && focused) {
|
|
try {
|
|
var value = input.value;
|
|
var _selectionRef$current = selectionRef.current,
|
|
beforeTxt = _selectionRef$current.beforeTxt,
|
|
afterTxt = _selectionRef$current.afterTxt,
|
|
start = _selectionRef$current.start;
|
|
var startPos = value.length;
|
|
if (value.endsWith(afterTxt)) {
|
|
startPos = value.length - selectionRef.current.afterTxt.length;
|
|
} else if (value.startsWith(beforeTxt)) {
|
|
startPos = beforeTxt.length;
|
|
} else {
|
|
var beforeLastChar = beforeTxt[start - 1];
|
|
var newIndex = value.indexOf(beforeLastChar, start - 1);
|
|
if (newIndex !== -1) {
|
|
startPos = newIndex + 1;
|
|
}
|
|
}
|
|
input.setSelectionRange(startPos, startPos);
|
|
} catch (e) {
|
|
(0,warning/* default */.ZP)(false, "Something warning of cursor restore. Please fire issue about this: ".concat(e.message));
|
|
}
|
|
}
|
|
}
|
|
return [recordCursor, restoreCursor];
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/raf.js
|
|
var raf = __webpack_require__(75164);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/hooks/useFrame.js
|
|
|
|
|
|
/**
|
|
* Always trigger latest once when call multiple time
|
|
*/
|
|
/* harmony default export */ var useFrame = (function () {
|
|
var idRef = (0,react.useRef)(0);
|
|
var cleanUp = function cleanUp() {
|
|
raf/* default.cancel */.Z.cancel(idRef.current);
|
|
};
|
|
(0,react.useEffect)(function () {
|
|
return cleanUp;
|
|
}, []);
|
|
return function (callback) {
|
|
cleanUp();
|
|
idRef.current = (0,raf/* default */.Z)(function () {
|
|
callback();
|
|
});
|
|
};
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/InputNumber.js
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["prefixCls", "className", "style", "min", "max", "step", "defaultValue", "value", "disabled", "readOnly", "upHandler", "downHandler", "keyboard", "controls", "stringMode", "parser", "formatter", "precision", "decimalSeparator", "onChange", "onInput", "onPressEnter", "onStep"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* We support `stringMode` which need handle correct type when user call in onChange
|
|
* format max or min value
|
|
* 1. if isInvalid return null
|
|
* 2. if precision is undefined, return decimal
|
|
* 3. format with precision
|
|
* I. if max > 0, round down with precision. Example: max= 3.5, precision=0 afterFormat: 3
|
|
* II. if max < 0, round up with precision. Example: max= -3.5, precision=0 afterFormat: -4
|
|
* III. if min > 0, round up with precision. Example: min= 3.5, precision=0 afterFormat: 4
|
|
* IV. if min < 0, round down with precision. Example: max= -3.5, precision=0 afterFormat: -3
|
|
*/
|
|
var getDecimalValue = function getDecimalValue(stringMode, decimalValue) {
|
|
if (stringMode || decimalValue.isEmpty()) {
|
|
return decimalValue.toString();
|
|
}
|
|
return decimalValue.toNumber();
|
|
};
|
|
var getDecimalIfValidate = function getDecimalIfValidate(value) {
|
|
var decimal = getMiniDecimal(value);
|
|
return decimal.isInvalidate() ? null : decimal;
|
|
};
|
|
var InputNumber = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _classNames;
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-input-number' : _props$prefixCls,
|
|
className = props.className,
|
|
style = props.style,
|
|
min = props.min,
|
|
max = props.max,
|
|
_props$step = props.step,
|
|
step = _props$step === void 0 ? 1 : _props$step,
|
|
defaultValue = props.defaultValue,
|
|
value = props.value,
|
|
disabled = props.disabled,
|
|
readOnly = props.readOnly,
|
|
upHandler = props.upHandler,
|
|
downHandler = props.downHandler,
|
|
keyboard = props.keyboard,
|
|
_props$controls = props.controls,
|
|
controls = _props$controls === void 0 ? true : _props$controls,
|
|
stringMode = props.stringMode,
|
|
parser = props.parser,
|
|
formatter = props.formatter,
|
|
precision = props.precision,
|
|
decimalSeparator = props.decimalSeparator,
|
|
onChange = props.onChange,
|
|
onInput = props.onInput,
|
|
onPressEnter = props.onPressEnter,
|
|
onStep = props.onStep,
|
|
inputProps = (0,objectWithoutProperties/* default */.Z)(props, _excluded);
|
|
var inputClassName = "".concat(prefixCls, "-input");
|
|
var inputRef = react.useRef(null);
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
focus = _React$useState2[0],
|
|
setFocus = _React$useState2[1];
|
|
var userTypingRef = react.useRef(false);
|
|
var compositionRef = react.useRef(false);
|
|
var shiftKeyRef = react.useRef(false);
|
|
// ============================ Value =============================
|
|
// Real value control
|
|
var _React$useState3 = react.useState(function () {
|
|
return getMiniDecimal(value !== null && value !== void 0 ? value : defaultValue);
|
|
}),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
decimalValue = _React$useState4[0],
|
|
setDecimalValue = _React$useState4[1];
|
|
function setUncontrolledDecimalValue(newDecimal) {
|
|
if (value === undefined) {
|
|
setDecimalValue(newDecimal);
|
|
}
|
|
}
|
|
// ====================== Parser & Formatter ======================
|
|
/**
|
|
* `precision` is used for formatter & onChange.
|
|
* It will auto generate by `value` & `step`.
|
|
* But it will not block user typing.
|
|
*
|
|
* Note: Auto generate `precision` is used for legacy logic.
|
|
* We should remove this since we already support high precision with BigInt.
|
|
*
|
|
* @param number Provide which number should calculate precision
|
|
* @param userTyping Change by user typing
|
|
*/
|
|
var getPrecision = react.useCallback(function (numStr, userTyping) {
|
|
if (userTyping) {
|
|
return undefined;
|
|
}
|
|
if (precision >= 0) {
|
|
return precision;
|
|
}
|
|
return Math.max(getNumberPrecision(numStr), getNumberPrecision(step));
|
|
}, [precision, step]);
|
|
// >>> Parser
|
|
var mergedParser = react.useCallback(function (num) {
|
|
var numStr = String(num);
|
|
if (parser) {
|
|
return parser(numStr);
|
|
}
|
|
var parsedStr = numStr;
|
|
if (decimalSeparator) {
|
|
parsedStr = parsedStr.replace(decimalSeparator, '.');
|
|
}
|
|
// [Legacy] We still support auto convert `$ 123,456` to `123456`
|
|
return parsedStr.replace(/[^\w.-]+/g, '');
|
|
}, [parser, decimalSeparator]);
|
|
// >>> Formatter
|
|
var inputValueRef = react.useRef('');
|
|
var mergedFormatter = react.useCallback(function (number, userTyping) {
|
|
if (formatter) {
|
|
return formatter(number, {
|
|
userTyping: userTyping,
|
|
input: String(inputValueRef.current)
|
|
});
|
|
}
|
|
var str = typeof number === 'number' ? num2str(number) : number;
|
|
// User typing will not auto format with precision directly
|
|
if (!userTyping) {
|
|
var mergedPrecision = getPrecision(str, userTyping);
|
|
if (validateNumber(str) && (decimalSeparator || mergedPrecision >= 0)) {
|
|
// Separator
|
|
var separatorStr = decimalSeparator || '.';
|
|
str = toFixed(str, separatorStr, mergedPrecision);
|
|
}
|
|
}
|
|
return str;
|
|
}, [formatter, getPrecision, decimalSeparator]);
|
|
// ========================== InputValue ==========================
|
|
/**
|
|
* Input text value control
|
|
*
|
|
* User can not update input content directly. It update with follow rules by priority:
|
|
* 1. controlled `value` changed
|
|
* * [SPECIAL] Typing like `1.` should not immediately convert to `1`
|
|
* 2. User typing with format (not precision)
|
|
* 3. Blur or Enter trigger revalidate
|
|
*/
|
|
var _React$useState5 = react.useState(function () {
|
|
var initValue = defaultValue !== null && defaultValue !== void 0 ? defaultValue : value;
|
|
if (decimalValue.isInvalidate() && ['string', 'number'].includes((0,esm_typeof/* default */.Z)(initValue))) {
|
|
return Number.isNaN(initValue) ? '' : initValue;
|
|
}
|
|
return mergedFormatter(decimalValue.toString(), false);
|
|
}),
|
|
_React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2),
|
|
inputValue = _React$useState6[0],
|
|
setInternalInputValue = _React$useState6[1];
|
|
inputValueRef.current = inputValue;
|
|
// Should always be string
|
|
function setInputValue(newValue, userTyping) {
|
|
setInternalInputValue(mergedFormatter(
|
|
// Invalidate number is sometime passed by external control, we should let it go
|
|
// Otherwise is controlled by internal interactive logic which check by userTyping
|
|
// You can ref 'show limited value when input is not focused' test for more info.
|
|
newValue.isInvalidate() ? newValue.toString(false) : newValue.toString(!userTyping), userTyping));
|
|
}
|
|
// >>> Max & Min limit
|
|
var maxDecimal = react.useMemo(function () {
|
|
return getDecimalIfValidate(max);
|
|
}, [max, precision]);
|
|
var minDecimal = react.useMemo(function () {
|
|
return getDecimalIfValidate(min);
|
|
}, [min, precision]);
|
|
var upDisabled = react.useMemo(function () {
|
|
if (!maxDecimal || !decimalValue || decimalValue.isInvalidate()) {
|
|
return false;
|
|
}
|
|
return maxDecimal.lessEquals(decimalValue);
|
|
}, [maxDecimal, decimalValue]);
|
|
var downDisabled = react.useMemo(function () {
|
|
if (!minDecimal || !decimalValue || decimalValue.isInvalidate()) {
|
|
return false;
|
|
}
|
|
return decimalValue.lessEquals(minDecimal);
|
|
}, [minDecimal, decimalValue]);
|
|
// Cursor controller
|
|
var _useCursor = useCursor(inputRef.current, focus),
|
|
_useCursor2 = (0,slicedToArray/* default */.Z)(_useCursor, 2),
|
|
recordCursor = _useCursor2[0],
|
|
restoreCursor = _useCursor2[1];
|
|
// ============================= Data =============================
|
|
/**
|
|
* Find target value closet within range.
|
|
* e.g. [11, 28]:
|
|
* 3 => 11
|
|
* 23 => 23
|
|
* 99 => 28
|
|
*/
|
|
var getRangeValue = function getRangeValue(target) {
|
|
// target > max
|
|
if (maxDecimal && !target.lessEquals(maxDecimal)) {
|
|
return maxDecimal;
|
|
}
|
|
// target < min
|
|
if (minDecimal && !minDecimal.lessEquals(target)) {
|
|
return minDecimal;
|
|
}
|
|
return null;
|
|
};
|
|
/**
|
|
* Check value is in [min, max] range
|
|
*/
|
|
var isInRange = function isInRange(target) {
|
|
return !getRangeValue(target);
|
|
};
|
|
/**
|
|
* Trigger `onChange` if value validated and not equals of origin.
|
|
* Return the value that re-align in range.
|
|
*/
|
|
var triggerValueUpdate = function triggerValueUpdate(newValue, userTyping) {
|
|
var updateValue = newValue;
|
|
var isRangeValidate = isInRange(updateValue) || updateValue.isEmpty();
|
|
// Skip align value when trigger value is empty.
|
|
// We just trigger onChange(null)
|
|
// This should not block user typing
|
|
if (!updateValue.isEmpty() && !userTyping) {
|
|
// Revert value in range if needed
|
|
updateValue = getRangeValue(updateValue) || updateValue;
|
|
isRangeValidate = true;
|
|
}
|
|
if (!readOnly && !disabled && isRangeValidate) {
|
|
var numStr = updateValue.toString();
|
|
var mergedPrecision = getPrecision(numStr, userTyping);
|
|
if (mergedPrecision >= 0) {
|
|
updateValue = getMiniDecimal(toFixed(numStr, '.', mergedPrecision));
|
|
// When to fixed. The value may out of min & max range.
|
|
// 4 in [0, 3.8] => 3.8 => 4 (toFixed)
|
|
if (!isInRange(updateValue)) {
|
|
updateValue = getMiniDecimal(toFixed(numStr, '.', mergedPrecision, true));
|
|
}
|
|
}
|
|
// Trigger event
|
|
if (!updateValue.equals(decimalValue)) {
|
|
setUncontrolledDecimalValue(updateValue);
|
|
onChange === null || onChange === void 0 ? void 0 : onChange(updateValue.isEmpty() ? null : getDecimalValue(stringMode, updateValue));
|
|
// Reformat input if value is not controlled
|
|
if (value === undefined) {
|
|
setInputValue(updateValue, userTyping);
|
|
}
|
|
}
|
|
return updateValue;
|
|
}
|
|
return decimalValue;
|
|
};
|
|
// ========================== User Input ==========================
|
|
var onNextPromise = useFrame();
|
|
// >>> Collect input value
|
|
var collectInputValue = function collectInputValue(inputStr) {
|
|
recordCursor();
|
|
// Update inputValue incase input can not parse as number
|
|
setInternalInputValue(inputStr);
|
|
// Parse number
|
|
if (!compositionRef.current) {
|
|
var finalValue = mergedParser(inputStr);
|
|
var finalDecimal = getMiniDecimal(finalValue);
|
|
if (!finalDecimal.isNaN()) {
|
|
triggerValueUpdate(finalDecimal, true);
|
|
}
|
|
}
|
|
// Trigger onInput later to let user customize value if they want do handle something after onChange
|
|
onInput === null || onInput === void 0 ? void 0 : onInput(inputStr);
|
|
// optimize for chinese input experience
|
|
// https://github.com/ant-design/ant-design/issues/8196
|
|
onNextPromise(function () {
|
|
var nextInputStr = inputStr;
|
|
if (!parser) {
|
|
nextInputStr = inputStr.replace(/。/g, '.');
|
|
}
|
|
if (nextInputStr !== inputStr) {
|
|
collectInputValue(nextInputStr);
|
|
}
|
|
});
|
|
};
|
|
// >>> Composition
|
|
var onCompositionStart = function onCompositionStart() {
|
|
compositionRef.current = true;
|
|
};
|
|
var onCompositionEnd = function onCompositionEnd() {
|
|
compositionRef.current = false;
|
|
collectInputValue(inputRef.current.value);
|
|
};
|
|
// >>> Input
|
|
var onInternalInput = function onInternalInput(e) {
|
|
collectInputValue(e.target.value);
|
|
};
|
|
// ============================= Step =============================
|
|
var onInternalStep = function onInternalStep(up) {
|
|
var _inputRef$current;
|
|
// Ignore step since out of range
|
|
if (up && upDisabled || !up && downDisabled) {
|
|
return;
|
|
}
|
|
// Clear typing status since it may caused by up & down key.
|
|
// We should sync with input value.
|
|
userTypingRef.current = false;
|
|
var stepDecimal = getMiniDecimal(shiftKeyRef.current ? getDecupleSteps(step) : step);
|
|
if (!up) {
|
|
stepDecimal = stepDecimal.negate();
|
|
}
|
|
var target = (decimalValue || getMiniDecimal(0)).add(stepDecimal.toString());
|
|
var updatedValue = triggerValueUpdate(target, false);
|
|
onStep === null || onStep === void 0 ? void 0 : onStep(getDecimalValue(stringMode, updatedValue), {
|
|
offset: shiftKeyRef.current ? getDecupleSteps(step) : step,
|
|
type: up ? 'up' : 'down'
|
|
});
|
|
(_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus();
|
|
};
|
|
// ============================ Flush =============================
|
|
/**
|
|
* Flush current input content to trigger value change & re-formatter input if needed
|
|
*/
|
|
var flushInputValue = function flushInputValue(userTyping) {
|
|
var parsedValue = getMiniDecimal(mergedParser(inputValue));
|
|
var formatValue = parsedValue;
|
|
if (!parsedValue.isNaN()) {
|
|
// Only validate value or empty value can be re-fill to inputValue
|
|
// Reassign the formatValue within ranged of trigger control
|
|
formatValue = triggerValueUpdate(parsedValue, userTyping);
|
|
} else {
|
|
formatValue = decimalValue;
|
|
}
|
|
if (value !== undefined) {
|
|
// Reset back with controlled value first
|
|
setInputValue(decimalValue, false);
|
|
} else if (!formatValue.isNaN()) {
|
|
// Reset input back since no validate value
|
|
setInputValue(formatValue, false);
|
|
}
|
|
};
|
|
// Solve the issue of the event triggering sequence when entering numbers in chinese input (Safari)
|
|
var onBeforeInput = function onBeforeInput() {
|
|
userTypingRef.current = true;
|
|
};
|
|
var onKeyDown = function onKeyDown(event) {
|
|
var which = event.which,
|
|
shiftKey = event.shiftKey;
|
|
userTypingRef.current = true;
|
|
if (shiftKey) {
|
|
shiftKeyRef.current = true;
|
|
} else {
|
|
shiftKeyRef.current = false;
|
|
}
|
|
if (which === KeyCode/* default.ENTER */.Z.ENTER) {
|
|
if (!compositionRef.current) {
|
|
userTypingRef.current = false;
|
|
}
|
|
flushInputValue(false);
|
|
onPressEnter === null || onPressEnter === void 0 ? void 0 : onPressEnter(event);
|
|
}
|
|
if (keyboard === false) {
|
|
return;
|
|
}
|
|
// Do step
|
|
if (!compositionRef.current && [KeyCode/* default.UP */.Z.UP, KeyCode/* default.DOWN */.Z.DOWN].includes(which)) {
|
|
onInternalStep(KeyCode/* default.UP */.Z.UP === which);
|
|
event.preventDefault();
|
|
}
|
|
};
|
|
var onKeyUp = function onKeyUp() {
|
|
userTypingRef.current = false;
|
|
shiftKeyRef.current = false;
|
|
};
|
|
// >>> Focus & Blur
|
|
var onBlur = function onBlur() {
|
|
flushInputValue(false);
|
|
setFocus(false);
|
|
userTypingRef.current = false;
|
|
};
|
|
// ========================== Controlled ==========================
|
|
// Input by precision
|
|
(0,useLayoutEffect/* useLayoutUpdateEffect */.o)(function () {
|
|
if (!decimalValue.isInvalidate()) {
|
|
setInputValue(decimalValue, false);
|
|
}
|
|
}, [precision]);
|
|
// Input by value
|
|
(0,useLayoutEffect/* useLayoutUpdateEffect */.o)(function () {
|
|
var newValue = getMiniDecimal(value);
|
|
setDecimalValue(newValue);
|
|
var currentParsedValue = getMiniDecimal(mergedParser(inputValue));
|
|
// When user typing from `1.2` to `1.`, we should not convert to `1` immediately.
|
|
// But let it go if user set `formatter`
|
|
if (!newValue.equals(currentParsedValue) || !userTypingRef.current || formatter) {
|
|
// Update value as effect
|
|
setInputValue(newValue, userTypingRef.current);
|
|
}
|
|
}, [value]);
|
|
// ============================ Cursor ============================
|
|
(0,useLayoutEffect/* useLayoutUpdateEffect */.o)(function () {
|
|
if (formatter) {
|
|
restoreCursor();
|
|
}
|
|
}, [inputValue]);
|
|
// ============================ Render ============================
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(prefixCls, className, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-focused"), focus), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-disabled"), disabled), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-readonly"), readOnly), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-not-a-number"), decimalValue.isNaN()), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-out-of-range"), !decimalValue.isInvalidate() && !isInRange(decimalValue)), _classNames)),
|
|
style: style,
|
|
onFocus: function onFocus() {
|
|
setFocus(true);
|
|
},
|
|
onBlur: onBlur,
|
|
onKeyDown: onKeyDown,
|
|
onKeyUp: onKeyUp,
|
|
onCompositionStart: onCompositionStart,
|
|
onCompositionEnd: onCompositionEnd,
|
|
onBeforeInput: onBeforeInput
|
|
}, controls && /*#__PURE__*/react.createElement(StepHandler, {
|
|
prefixCls: prefixCls,
|
|
upNode: upHandler,
|
|
downNode: downHandler,
|
|
upDisabled: upDisabled,
|
|
downDisabled: downDisabled,
|
|
onStep: onInternalStep
|
|
}), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(inputClassName, "-wrap")
|
|
}, /*#__PURE__*/react.createElement("input", (0,esm_extends/* default */.Z)({
|
|
autoComplete: "off",
|
|
role: "spinbutton",
|
|
"aria-valuemin": min,
|
|
"aria-valuemax": max,
|
|
"aria-valuenow": decimalValue.isInvalidate() ? null : decimalValue.toString(),
|
|
step: step
|
|
}, inputProps, {
|
|
ref: (0,es_ref/* composeRef */.sQ)(inputRef, ref),
|
|
className: inputClassName,
|
|
value: inputValue,
|
|
onChange: onInternalInput,
|
|
disabled: disabled,
|
|
readOnly: readOnly
|
|
}))));
|
|
});
|
|
InputNumber.displayName = 'InputNumber';
|
|
/* harmony default export */ var es_InputNumber = (InputNumber);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-input-number/es/index.js
|
|
|
|
/* harmony default export */ var es = (es_InputNumber);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/context.js
|
|
var context = __webpack_require__(53124);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/DisabledContext.js
|
|
var DisabledContext = __webpack_require__(98866);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/SizeContext.js
|
|
var SizeContext = __webpack_require__(97647);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/form/context.js
|
|
var form_context = __webpack_require__(65223);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/space/Compact.js
|
|
var Compact = __webpack_require__(4173);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/reactNode.js
|
|
var reactNode = __webpack_require__(96159);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/statusUtils.js
|
|
var statusUtils = __webpack_require__(9708);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/input-number/index.js
|
|
|
|
|
|
|
|
|
|
var __rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var input_number_InputNumber = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _classNames;
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getPrefixCls = _React$useContext.getPrefixCls,
|
|
direction = _React$useContext.direction;
|
|
var size = react.useContext(SizeContext/* default */.Z);
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
focused = _React$useState2[0],
|
|
setFocus = _React$useState2[1];
|
|
var inputRef = react.useRef(null);
|
|
react.useImperativeHandle(ref, function () {
|
|
return inputRef.current;
|
|
});
|
|
var className = props.className,
|
|
customizeSize = props.size,
|
|
customDisabled = props.disabled,
|
|
customizePrefixCls = props.prefixCls,
|
|
addonBefore = props.addonBefore,
|
|
addonAfter = props.addonAfter,
|
|
prefix = props.prefix,
|
|
_props$bordered = props.bordered,
|
|
bordered = _props$bordered === void 0 ? true : _props$bordered,
|
|
readOnly = props.readOnly,
|
|
customStatus = props.status,
|
|
controls = props.controls,
|
|
others = __rest(props, ["className", "size", "disabled", "prefixCls", "addonBefore", "addonAfter", "prefix", "bordered", "readOnly", "status", "controls"]);
|
|
var prefixCls = getPrefixCls('input-number', customizePrefixCls);
|
|
var _useCompactItemContex = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction),
|
|
compactSize = _useCompactItemContex.compactSize,
|
|
compactItemClassnames = _useCompactItemContex.compactItemClassnames;
|
|
var upIcon = /*#__PURE__*/react.createElement(icons_UpOutlined, {
|
|
className: "".concat(prefixCls, "-handler-up-inner")
|
|
});
|
|
var downIcon = /*#__PURE__*/react.createElement(DownOutlined/* default */.Z, {
|
|
className: "".concat(prefixCls, "-handler-down-inner")
|
|
});
|
|
var controlsTemp = typeof controls === 'boolean' ? controls : undefined;
|
|
if ((0,esm_typeof/* default */.Z)(controls) === 'object') {
|
|
upIcon = typeof controls.upIcon === 'undefined' ? upIcon : /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-handler-up-inner")
|
|
}, controls.upIcon);
|
|
downIcon = typeof controls.downIcon === 'undefined' ? downIcon : /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-handler-down-inner")
|
|
}, controls.downIcon);
|
|
}
|
|
var _useContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM),
|
|
hasFeedback = _useContext.hasFeedback,
|
|
contextStatus = _useContext.status,
|
|
isFormItemInput = _useContext.isFormItemInput,
|
|
feedbackIcon = _useContext.feedbackIcon;
|
|
var mergedStatus = (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus);
|
|
var mergeSize = compactSize || customizeSize || size;
|
|
// ===================== Disabled =====================
|
|
var disabled = react.useContext(DisabledContext/* default */.Z);
|
|
var mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
var inputNumberClass = classnames_default()((_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-lg"), mergeSize === 'large'), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-sm"), mergeSize === 'small'), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-borderless"), !bordered), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-in-form-item"), isFormItemInput), _classNames), (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, mergedStatus), compactItemClassnames, className);
|
|
var element = /*#__PURE__*/react.createElement(es, (0,esm_extends/* default */.Z)({
|
|
ref: inputRef,
|
|
disabled: mergedDisabled,
|
|
className: inputNumberClass,
|
|
upHandler: upIcon,
|
|
downHandler: downIcon,
|
|
prefixCls: prefixCls,
|
|
readOnly: readOnly,
|
|
controls: controlsTemp
|
|
}, others));
|
|
if (prefix != null || hasFeedback) {
|
|
var _classNames2;
|
|
var affixWrapperCls = classnames_default()("".concat(prefixCls, "-affix-wrapper"), (0,statusUtils/* getStatusClassNames */.Z)("".concat(prefixCls, "-affix-wrapper"), mergedStatus, hasFeedback), (_classNames2 = {}, (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-focused"), focused), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-disabled"), props.disabled), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-sm"), size === 'small'), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-lg"), size === 'large'), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-rtl"), direction === 'rtl'), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-readonly"), readOnly), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-affix-wrapper-borderless"), !bordered), (0,defineProperty/* default */.Z)(_classNames2, "".concat(className), !(addonBefore || addonAfter) && className), _classNames2));
|
|
element = /*#__PURE__*/react.createElement("div", {
|
|
className: affixWrapperCls,
|
|
style: props.style,
|
|
onMouseUp: function onMouseUp() {
|
|
return inputRef.current.focus();
|
|
}
|
|
}, prefix && /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-prefix")
|
|
}, prefix), (0,reactNode/* cloneElement */.Tm)(element, {
|
|
style: null,
|
|
value: props.value,
|
|
onFocus: function onFocus(event) {
|
|
var _a;
|
|
setFocus(true);
|
|
(_a = props.onFocus) === null || _a === void 0 ? void 0 : _a.call(props, event);
|
|
},
|
|
onBlur: function onBlur(event) {
|
|
var _a;
|
|
setFocus(false);
|
|
(_a = props.onBlur) === null || _a === void 0 ? void 0 : _a.call(props, event);
|
|
}
|
|
}), hasFeedback && /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-suffix")
|
|
}, feedbackIcon));
|
|
}
|
|
if (addonBefore != null || addonAfter != null) {
|
|
var _classNames4;
|
|
var wrapperClassName = "".concat(prefixCls, "-group");
|
|
var addonClassName = "".concat(wrapperClassName, "-addon");
|
|
var addonBeforeNode = addonBefore ? /*#__PURE__*/react.createElement("div", {
|
|
className: addonClassName
|
|
}, addonBefore) : null;
|
|
var addonAfterNode = addonAfter ? /*#__PURE__*/react.createElement("div", {
|
|
className: addonClassName
|
|
}, addonAfter) : null;
|
|
var mergedWrapperClassName = classnames_default()("".concat(prefixCls, "-wrapper"), wrapperClassName, (0,defineProperty/* default */.Z)({}, "".concat(wrapperClassName, "-rtl"), direction === 'rtl'));
|
|
var mergedGroupClassName = classnames_default()("".concat(prefixCls, "-group-wrapper"), (_classNames4 = {}, (0,defineProperty/* default */.Z)(_classNames4, "".concat(prefixCls, "-group-wrapper-sm"), size === 'small'), (0,defineProperty/* default */.Z)(_classNames4, "".concat(prefixCls, "-group-wrapper-lg"), size === 'large'), (0,defineProperty/* default */.Z)(_classNames4, "".concat(prefixCls, "-group-wrapper-rtl"), direction === 'rtl'), _classNames4), (0,statusUtils/* getStatusClassNames */.Z)("".concat(prefixCls, "-group-wrapper"), mergedStatus, hasFeedback), className);
|
|
element = /*#__PURE__*/react.createElement("div", {
|
|
className: mergedGroupClassName,
|
|
style: props.style
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
className: mergedWrapperClassName
|
|
}, addonBeforeNode && /*#__PURE__*/react.createElement(Compact/* NoCompactStyle */.BR, null, /*#__PURE__*/react.createElement(form_context/* NoFormStyle */.Ux, {
|
|
status: true,
|
|
override: true
|
|
}, addonBeforeNode)), (0,reactNode/* cloneElement */.Tm)(element, {
|
|
style: null,
|
|
disabled: mergedDisabled
|
|
}), addonAfterNode && /*#__PURE__*/react.createElement(Compact/* NoCompactStyle */.BR, null, /*#__PURE__*/react.createElement(form_context/* NoFormStyle */.Ux, {
|
|
status: true,
|
|
override: true
|
|
}, addonAfterNode))));
|
|
}
|
|
return element;
|
|
});
|
|
/* harmony default export */ var input_number = (input_number_InputNumber);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 25359:
|
|
/*!**********************************************************************!*\
|
|
!*** ./node_modules/antd/es/input-number/style/index.js + 1 modules ***!
|
|
\**********************************************************************/
|
|
/***/ (function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/default.less
|
|
var style_default = __webpack_require__(43146);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/input-number/style/index.less
|
|
// extracted by mini-css-extract-plugin
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/input-number/style/index.js
|
|
|
|
|
|
// deps-lint-skip: form, space
|
|
|
|
/***/ }),
|
|
|
|
/***/ 29924:
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/antd/es/radio/index.js + 4 modules ***!
|
|
\*********************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"ZP": function() { return /* binding */ es_radio; }
|
|
});
|
|
|
|
// UNUSED EXPORTS: Button, Group
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMergedState.js
|
|
var useMergedState = __webpack_require__(21770);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/context.js
|
|
var context = __webpack_require__(53124);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/SizeContext.js
|
|
var SizeContext = __webpack_require__(97647);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/getDataOrAriaProps.js
|
|
var getDataOrAriaProps = __webpack_require__(5467);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/context.js
|
|
|
|
var RadioGroupContext = /*#__PURE__*/react.createContext(null);
|
|
var RadioGroupContextProvider = RadioGroupContext.Provider;
|
|
/* harmony default export */ var radio_context = (RadioGroupContext);
|
|
var RadioOptionTypeContext = /*#__PURE__*/react.createContext(null);
|
|
var RadioOptionTypeContextProvider = RadioOptionTypeContext.Provider;
|
|
// EXTERNAL MODULE: ./node_modules/rc-checkbox/es/index.js
|
|
var es = __webpack_require__(50132);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/ref.js
|
|
var es_ref = __webpack_require__(42550);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/config-provider/DisabledContext.js
|
|
var DisabledContext = __webpack_require__(98866);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/form/context.js
|
|
var form_context = __webpack_require__(65223);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/radio.js
|
|
|
|
|
|
var __rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var InternalRadio = function InternalRadio(props, ref) {
|
|
var _classNames;
|
|
var groupContext = react.useContext(radio_context);
|
|
var radioOptionTypeContext = react.useContext(RadioOptionTypeContext);
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getPrefixCls = _React$useContext.getPrefixCls,
|
|
direction = _React$useContext.direction;
|
|
var innerRef = react.useRef();
|
|
var mergedRef = (0,es_ref/* composeRef */.sQ)(ref, innerRef);
|
|
var _useContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM),
|
|
isFormItemInput = _useContext.isFormItemInput;
|
|
false ? 0 : void 0;
|
|
var onChange = function onChange(e) {
|
|
var _a, _b;
|
|
(_a = props.onChange) === null || _a === void 0 ? void 0 : _a.call(props, e);
|
|
(_b = groupContext === null || groupContext === void 0 ? void 0 : groupContext.onChange) === null || _b === void 0 ? void 0 : _b.call(groupContext, e);
|
|
};
|
|
var customizePrefixCls = props.prefixCls,
|
|
className = props.className,
|
|
children = props.children,
|
|
style = props.style,
|
|
customDisabled = props.disabled,
|
|
restProps = __rest(props, ["prefixCls", "className", "children", "style", "disabled"]);
|
|
var radioPrefixCls = getPrefixCls('radio', customizePrefixCls);
|
|
var prefixCls = ((groupContext === null || groupContext === void 0 ? void 0 : groupContext.optionType) || radioOptionTypeContext) === 'button' ? "".concat(radioPrefixCls, "-button") : radioPrefixCls;
|
|
var radioProps = (0,esm_extends/* default */.Z)({}, restProps);
|
|
// ===================== Disabled =====================
|
|
var disabled = react.useContext(DisabledContext/* default */.Z);
|
|
radioProps.disabled = customDisabled || disabled;
|
|
if (groupContext) {
|
|
radioProps.name = groupContext.name;
|
|
radioProps.onChange = onChange;
|
|
radioProps.checked = props.value === groupContext.value;
|
|
radioProps.disabled = radioProps.disabled || groupContext.disabled;
|
|
}
|
|
var wrapperClassString = classnames_default()("".concat(prefixCls, "-wrapper"), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-wrapper-checked"), radioProps.checked), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-wrapper-disabled"), radioProps.disabled), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-wrapper-rtl"), direction === 'rtl'), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-wrapper-in-form-item"), isFormItemInput), _classNames), className);
|
|
return (
|
|
/*#__PURE__*/
|
|
// eslint-disable-next-line jsx-a11y/label-has-associated-control
|
|
react.createElement("label", {
|
|
className: wrapperClassString,
|
|
style: style,
|
|
onMouseEnter: props.onMouseEnter,
|
|
onMouseLeave: props.onMouseLeave
|
|
}, /*#__PURE__*/react.createElement(es/* default */.Z, (0,esm_extends/* default */.Z)({}, radioProps, {
|
|
type: "radio",
|
|
prefixCls: prefixCls,
|
|
ref: mergedRef
|
|
})), children !== undefined ? /*#__PURE__*/react.createElement("span", null, children) : null)
|
|
);
|
|
};
|
|
var Radio = /*#__PURE__*/react.forwardRef(InternalRadio);
|
|
if (false) {}
|
|
/* harmony default export */ var radio_radio = (Radio);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/group.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var RadioGroup = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _classNames;
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getPrefixCls = _React$useContext.getPrefixCls,
|
|
direction = _React$useContext.direction;
|
|
var size = react.useContext(SizeContext/* default */.Z);
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(props.defaultValue, {
|
|
value: props.value
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
value = _useMergedState2[0],
|
|
setValue = _useMergedState2[1];
|
|
var onRadioChange = function onRadioChange(ev) {
|
|
var lastValue = value;
|
|
var val = ev.target.value;
|
|
if (!('value' in props)) {
|
|
setValue(val);
|
|
}
|
|
var onChange = props.onChange;
|
|
if (onChange && val !== lastValue) {
|
|
onChange(ev);
|
|
}
|
|
};
|
|
var customizePrefixCls = props.prefixCls,
|
|
_props$className = props.className,
|
|
className = _props$className === void 0 ? '' : _props$className,
|
|
options = props.options,
|
|
_props$buttonStyle = props.buttonStyle,
|
|
buttonStyle = _props$buttonStyle === void 0 ? 'outline' : _props$buttonStyle,
|
|
disabled = props.disabled,
|
|
children = props.children,
|
|
customizeSize = props.size,
|
|
style = props.style,
|
|
id = props.id,
|
|
onMouseEnter = props.onMouseEnter,
|
|
onMouseLeave = props.onMouseLeave,
|
|
onFocus = props.onFocus,
|
|
onBlur = props.onBlur;
|
|
var prefixCls = getPrefixCls('radio', customizePrefixCls);
|
|
var groupPrefixCls = "".concat(prefixCls, "-group");
|
|
var childrenToRender = children;
|
|
// 如果存在 options, 优先使用
|
|
if (options && options.length > 0) {
|
|
childrenToRender = options.map(function (option) {
|
|
if (typeof option === 'string' || typeof option === 'number') {
|
|
// 此处类型自动推导为 string
|
|
return /*#__PURE__*/react.createElement(radio_radio, {
|
|
key: option.toString(),
|
|
prefixCls: prefixCls,
|
|
disabled: disabled,
|
|
value: option,
|
|
checked: value === option
|
|
}, option);
|
|
}
|
|
// 此处类型自动推导为 { label: string value: string }
|
|
return /*#__PURE__*/react.createElement(radio_radio, {
|
|
key: "radio-group-value-options-".concat(option.value),
|
|
prefixCls: prefixCls,
|
|
disabled: option.disabled || disabled,
|
|
value: option.value,
|
|
checked: value === option.value,
|
|
style: option.style
|
|
}, option.label);
|
|
});
|
|
}
|
|
var mergedSize = customizeSize || size;
|
|
var classString = classnames_default()(groupPrefixCls, "".concat(groupPrefixCls, "-").concat(buttonStyle), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(groupPrefixCls, "-").concat(mergedSize), mergedSize), (0,defineProperty/* default */.Z)(_classNames, "".concat(groupPrefixCls, "-rtl"), direction === 'rtl'), _classNames), className);
|
|
return /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({}, (0,getDataOrAriaProps/* default */.Z)(props), {
|
|
className: classString,
|
|
style: style,
|
|
onMouseEnter: onMouseEnter,
|
|
onMouseLeave: onMouseLeave,
|
|
onFocus: onFocus,
|
|
onBlur: onBlur,
|
|
id: id,
|
|
ref: ref
|
|
}), /*#__PURE__*/react.createElement(RadioGroupContextProvider, {
|
|
value: {
|
|
onChange: onRadioChange,
|
|
value: value,
|
|
disabled: props.disabled,
|
|
name: props.name,
|
|
optionType: props.optionType
|
|
}
|
|
}, childrenToRender));
|
|
});
|
|
/* harmony default export */ var group = (/*#__PURE__*/react.memo(RadioGroup));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/radioButton.js
|
|
|
|
var radioButton_rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
var RadioButton = function RadioButton(props, ref) {
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getPrefixCls = _React$useContext.getPrefixCls;
|
|
var customizePrefixCls = props.prefixCls,
|
|
radioProps = radioButton_rest(props, ["prefixCls"]);
|
|
var prefixCls = getPrefixCls('radio', customizePrefixCls);
|
|
return /*#__PURE__*/react.createElement(RadioOptionTypeContextProvider, {
|
|
value: "button"
|
|
}, /*#__PURE__*/react.createElement(radio_radio, (0,esm_extends/* default */.Z)({
|
|
prefixCls: prefixCls
|
|
}, radioProps, {
|
|
type: "radio",
|
|
ref: ref
|
|
})));
|
|
};
|
|
/* harmony default export */ var radioButton = (/*#__PURE__*/react.forwardRef(RadioButton));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/index.js
|
|
|
|
|
|
|
|
|
|
var radio_Radio = radio_radio;
|
|
radio_Radio.Button = radioButton;
|
|
radio_Radio.Group = group;
|
|
radio_Radio.__ANT_RADIO = true;
|
|
/* harmony default export */ var es_radio = (radio_Radio);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 83822:
|
|
/*!***************************************************************!*\
|
|
!*** ./node_modules/antd/es/radio/style/index.js + 1 modules ***!
|
|
\***************************************************************/
|
|
/***/ (function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/default.less
|
|
var style_default = __webpack_require__(43146);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/style/index.less
|
|
// extracted by mini-css-extract-plugin
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/radio/style/index.js
|
|
|
|
|
|
// deps-lint-skip: form
|
|
|
|
/***/ }),
|
|
|
|
/***/ 50132:
|
|
/*!**********************************************!*\
|
|
!*** ./node_modules/rc-checkbox/es/index.js ***!
|
|
\**********************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @babel/runtime/helpers/esm/extends */ 87462);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @babel/runtime/helpers/esm/defineProperty */ 4942);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @babel/runtime/helpers/esm/objectWithoutProperties */ 45987);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @babel/runtime/helpers/esm/objectSpread2 */ 1413);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_classCallCheck__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/esm/classCallCheck */ 15671);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_createClass__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/esm/createClass */ 43144);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_inherits__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/esm/inherits */ 60136);
|
|
/* harmony import */ var _babel_runtime_helpers_esm_createSuper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @babel/runtime/helpers/esm/createSuper */ 51630);
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ 67294);
|
|
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! classnames */ 94184);
|
|
/* harmony import */ var classnames__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(classnames__WEBPACK_IMPORTED_MODULE_1__);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// eslint-disable-next-line import/no-extraneous-dependencies
|
|
|
|
|
|
|
|
var Checkbox = /*#__PURE__*/function (_Component) {
|
|
(0,_babel_runtime_helpers_esm_inherits__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(Checkbox, _Component);
|
|
|
|
var _super = (0,_babel_runtime_helpers_esm_createSuper__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z)(Checkbox);
|
|
|
|
function Checkbox(props) {
|
|
var _this;
|
|
|
|
(0,_babel_runtime_helpers_esm_classCallCheck__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(this, Checkbox);
|
|
|
|
_this = _super.call(this, props);
|
|
|
|
_this.handleChange = function (e) {
|
|
var _this$props = _this.props,
|
|
disabled = _this$props.disabled,
|
|
onChange = _this$props.onChange;
|
|
|
|
if (disabled) {
|
|
return;
|
|
}
|
|
|
|
if (!('checked' in _this.props)) {
|
|
_this.setState({
|
|
checked: e.target.checked
|
|
});
|
|
}
|
|
|
|
if (onChange) {
|
|
onChange({
|
|
target: (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({}, _this.props), {}, {
|
|
checked: e.target.checked
|
|
}),
|
|
stopPropagation: function stopPropagation() {
|
|
e.stopPropagation();
|
|
},
|
|
preventDefault: function preventDefault() {
|
|
e.preventDefault();
|
|
},
|
|
nativeEvent: e.nativeEvent
|
|
});
|
|
}
|
|
};
|
|
|
|
_this.saveInput = function (node) {
|
|
_this.input = node;
|
|
};
|
|
|
|
var checked = 'checked' in props ? props.checked : props.defaultChecked;
|
|
_this.state = {
|
|
checked: checked
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
(0,_babel_runtime_helpers_esm_createClass__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)(Checkbox, [{
|
|
key: "focus",
|
|
value: function focus() {
|
|
this.input.focus();
|
|
}
|
|
}, {
|
|
key: "blur",
|
|
value: function blur() {
|
|
this.input.blur();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var _classNames;
|
|
|
|
var _this$props2 = this.props,
|
|
prefixCls = _this$props2.prefixCls,
|
|
className = _this$props2.className,
|
|
style = _this$props2.style,
|
|
name = _this$props2.name,
|
|
id = _this$props2.id,
|
|
type = _this$props2.type,
|
|
disabled = _this$props2.disabled,
|
|
readOnly = _this$props2.readOnly,
|
|
tabIndex = _this$props2.tabIndex,
|
|
onClick = _this$props2.onClick,
|
|
onFocus = _this$props2.onFocus,
|
|
onBlur = _this$props2.onBlur,
|
|
onKeyDown = _this$props2.onKeyDown,
|
|
onKeyPress = _this$props2.onKeyPress,
|
|
onKeyUp = _this$props2.onKeyUp,
|
|
autoFocus = _this$props2.autoFocus,
|
|
value = _this$props2.value,
|
|
required = _this$props2.required,
|
|
others = (0,_babel_runtime_helpers_esm_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z)(_this$props2, ["prefixCls", "className", "style", "name", "id", "type", "disabled", "readOnly", "tabIndex", "onClick", "onFocus", "onBlur", "onKeyDown", "onKeyPress", "onKeyUp", "autoFocus", "value", "required"]);
|
|
|
|
var globalProps = Object.keys(others).reduce(function (prev, key) {
|
|
if (key.substr(0, 5) === 'aria-' || key.substr(0, 5) === 'data-' || key === 'role') {
|
|
// eslint-disable-next-line no-param-reassign
|
|
prev[key] = others[key];
|
|
}
|
|
|
|
return prev;
|
|
}, {});
|
|
var checked = this.state.checked;
|
|
var classString = classnames__WEBPACK_IMPORTED_MODULE_1___default()(prefixCls, className, (_classNames = {}, (0,_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .Z)(_classNames, "".concat(prefixCls, "-checked"), checked), (0,_babel_runtime_helpers_esm_defineProperty__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .Z)(_classNames, "".concat(prefixCls, "-disabled"), disabled), _classNames));
|
|
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("span", {
|
|
className: classString,
|
|
style: style
|
|
}, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("input", (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .Z)({
|
|
name: name,
|
|
id: id,
|
|
type: type,
|
|
required: required,
|
|
readOnly: readOnly,
|
|
disabled: disabled,
|
|
tabIndex: tabIndex,
|
|
className: "".concat(prefixCls, "-input"),
|
|
checked: !!checked,
|
|
onClick: onClick,
|
|
onFocus: onFocus,
|
|
onBlur: onBlur,
|
|
onKeyUp: onKeyUp,
|
|
onKeyDown: onKeyDown,
|
|
onKeyPress: onKeyPress,
|
|
onChange: this.handleChange,
|
|
autoFocus: autoFocus,
|
|
ref: this.saveInput,
|
|
value: value
|
|
}, globalProps)), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("span", {
|
|
className: "".concat(prefixCls, "-inner")
|
|
}));
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(props, state) {
|
|
if ('checked' in props) {
|
|
return (0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)((0,_babel_runtime_helpers_esm_objectSpread2__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)({}, state), {}, {
|
|
checked: props.checked
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}]);
|
|
|
|
return Checkbox;
|
|
}(react__WEBPACK_IMPORTED_MODULE_0__.Component);
|
|
|
|
Checkbox.defaultProps = {
|
|
prefixCls: 'rc-checkbox',
|
|
className: '',
|
|
style: {},
|
|
type: 'checkbox',
|
|
defaultChecked: false,
|
|
onFocus: function onFocus() {},
|
|
onBlur: function onBlur() {},
|
|
onChange: function onChange() {},
|
|
onKeyDown: function onKeyDown() {},
|
|
onKeyPress: function onKeyPress() {},
|
|
onKeyUp: function onKeyUp() {}
|
|
};
|
|
/* harmony default export */ __webpack_exports__["Z"] = (Checkbox);
|
|
|
|
/***/ })
|
|
|
|
}]); |