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.
5394 lines
198 KiB
5394 lines
198 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[97278],{
|
|
|
|
/***/ 99011:
|
|
/*!**************************************************************************!*\
|
|
!*** ./node_modules/@ant-design/icons-svg/es/asn/ClockCircleOutlined.js ***!
|
|
\**************************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__) {
|
|
|
|
// This icon file is generated automatically.
|
|
var ClockCircleOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" } }, { "tag": "path", "attrs": { "d": "M686.7 638.6L544.1 535.5V288c0-4.4-3.6-8-8-8H488c-4.4 0-8 3.6-8 8v275.4c0 2.6 1.2 5 3.3 6.5l165.4 120.6c3.6 2.6 8.6 1.8 11.2-1.7l28.6-39c2.6-3.7 1.8-8.7-1.8-11.2z" } }] }, "name": "clock-circle", "theme": "outlined" };
|
|
/* harmony default export */ __webpack_exports__["Z"] = (ClockCircleOutlined);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 45741:
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/antd/es/date-picker/index.js + 56 modules ***!
|
|
\****************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ date_picker; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/moment/moment.js
|
|
var moment = __webpack_require__(30381);
|
|
var moment_default = /*#__PURE__*/__webpack_require__.n(moment);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/warning.js
|
|
var es_warning = __webpack_require__(80334);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/generate/moment.js
|
|
|
|
|
|
var generateConfig = {
|
|
// get
|
|
getNow: function getNow() {
|
|
return moment_default()();
|
|
},
|
|
getFixedDate: function getFixedDate(string) {
|
|
return moment_default()(string, 'YYYY-MM-DD');
|
|
},
|
|
getEndDate: function getEndDate(date) {
|
|
var clone = date.clone();
|
|
return clone.endOf('month');
|
|
},
|
|
getWeekDay: function getWeekDay(date) {
|
|
var clone = date.clone().locale('en_US');
|
|
return clone.weekday() + clone.localeData().firstDayOfWeek();
|
|
},
|
|
getYear: function getYear(date) {
|
|
return date.year();
|
|
},
|
|
getMonth: function getMonth(date) {
|
|
return date.month();
|
|
},
|
|
getDate: function getDate(date) {
|
|
return date.date();
|
|
},
|
|
getHour: function getHour(date) {
|
|
return date.hour();
|
|
},
|
|
getMinute: function getMinute(date) {
|
|
return date.minute();
|
|
},
|
|
getSecond: function getSecond(date) {
|
|
return date.second();
|
|
},
|
|
// set
|
|
addYear: function addYear(date, diff) {
|
|
var clone = date.clone();
|
|
return clone.add(diff, 'year');
|
|
},
|
|
addMonth: function addMonth(date, diff) {
|
|
var clone = date.clone();
|
|
return clone.add(diff, 'month');
|
|
},
|
|
addDate: function addDate(date, diff) {
|
|
var clone = date.clone();
|
|
return clone.add(diff, 'day');
|
|
},
|
|
setYear: function setYear(date, year) {
|
|
var clone = date.clone();
|
|
return clone.year(year);
|
|
},
|
|
setMonth: function setMonth(date, month) {
|
|
var clone = date.clone();
|
|
return clone.month(month);
|
|
},
|
|
setDate: function setDate(date, num) {
|
|
var clone = date.clone();
|
|
return clone.date(num);
|
|
},
|
|
setHour: function setHour(date, hour) {
|
|
var clone = date.clone();
|
|
return clone.hour(hour);
|
|
},
|
|
setMinute: function setMinute(date, minute) {
|
|
var clone = date.clone();
|
|
return clone.minute(minute);
|
|
},
|
|
setSecond: function setSecond(date, second) {
|
|
var clone = date.clone();
|
|
return clone.second(second);
|
|
},
|
|
// Compare
|
|
isAfter: function isAfter(date1, date2) {
|
|
return date1.isAfter(date2);
|
|
},
|
|
isValidate: function isValidate(date) {
|
|
return date.isValid();
|
|
},
|
|
locale: {
|
|
getWeekFirstDay: function getWeekFirstDay(locale) {
|
|
var date = moment_default()().locale(locale);
|
|
return date.localeData().firstDayOfWeek();
|
|
},
|
|
getWeekFirstDate: function getWeekFirstDate(locale, date) {
|
|
var clone = date.clone();
|
|
var result = clone.locale(locale);
|
|
return result.weekday(0);
|
|
},
|
|
getWeek: function getWeek(locale, date) {
|
|
var clone = date.clone();
|
|
var result = clone.locale(locale);
|
|
return result.week();
|
|
},
|
|
getShortWeekDays: function getShortWeekDays(locale) {
|
|
var date = moment_default()().locale(locale);
|
|
return date.localeData().weekdaysMin();
|
|
},
|
|
getShortMonths: function getShortMonths(locale) {
|
|
var date = moment_default()().locale(locale);
|
|
return date.localeData().monthsShort();
|
|
},
|
|
format: function format(locale, date, _format) {
|
|
var clone = date.clone();
|
|
var result = clone.locale(locale);
|
|
return result.format(_format);
|
|
},
|
|
parse: function parse(locale, text, formats) {
|
|
var fallbackFormatList = [];
|
|
for (var i = 0; i < formats.length; i += 1) {
|
|
var format = formats[i];
|
|
var formatText = text;
|
|
if (format.includes('wo') || format.includes('Wo')) {
|
|
format = format.replace(/wo/g, 'w').replace(/Wo/g, 'W');
|
|
var matchFormat = format.match(/[-YyMmDdHhSsWwGg]+/g);
|
|
var matchText = formatText.match(/[-\d]+/g);
|
|
if (matchFormat && matchText) {
|
|
format = matchFormat.join('');
|
|
formatText = matchText.join('');
|
|
} else {
|
|
fallbackFormatList.push(format.replace(/o/g, ''));
|
|
}
|
|
}
|
|
var date = moment_default()(formatText, format, locale, true);
|
|
if (date.isValid()) {
|
|
return date;
|
|
}
|
|
}
|
|
// Fallback to fuzzy matching, this should always not reach match or need fire a issue
|
|
for (var _i = 0; _i < fallbackFormatList.length; _i += 1) {
|
|
var _date = moment_default()(text, fallbackFormatList[_i], locale, false);
|
|
/* istanbul ignore next */
|
|
if (_date.isValid()) {
|
|
(0,es_warning/* noteOnce */.ET)(false, 'Not match any format strictly and fallback to fuzzy match. Please help to fire a issue about this.');
|
|
return _date;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
/* harmony default export */ var generate_moment = (generateConfig);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/type.js
|
|
var type = __webpack_require__(93355);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/button/index.js
|
|
var es_button = __webpack_require__(71577);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/PickerButton.js
|
|
|
|
|
|
|
|
function PickerButton(props) {
|
|
return /*#__PURE__*/react.createElement(es_button/* default */.Z, (0,esm_extends/* default */.Z)({
|
|
size: "small",
|
|
type: "primary"
|
|
}, props));
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/tag/index.js + 1 modules
|
|
var tag = __webpack_require__(20550);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/PickerTag.js
|
|
|
|
|
|
|
|
function PickerTag(props) {
|
|
return /*#__PURE__*/react.createElement(tag/* default */.Z, (0,esm_extends/* default */.Z)({
|
|
color: "blue"
|
|
}, props));
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/CalendarOutlined.js
|
|
// This icon file is generated automatically.
|
|
var CalendarOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M880 184H712v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H384v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H144c-17.7 0-32 14.3-32 32v664c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V216c0-17.7-14.3-32-32-32zm-40 656H184V460h656v380zM184 392V256h128v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h256v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h128v136H184z" } }] }, "name": "calendar", "theme": "outlined" };
|
|
/* harmony default export */ var asn_CalendarOutlined = (CalendarOutlined);
|
|
|
|
// 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/CalendarOutlined.js
|
|
|
|
// GENERATE BY ./scripts/generate.ts
|
|
// DON NOT EDIT IT MANUALLY
|
|
|
|
|
|
|
|
var CalendarOutlined_CalendarOutlined = function CalendarOutlined(props, ref) {
|
|
return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
ref: ref,
|
|
icon: asn_CalendarOutlined
|
|
}));
|
|
};
|
|
CalendarOutlined_CalendarOutlined.displayName = 'CalendarOutlined';
|
|
/* harmony default export */ var icons_CalendarOutlined = (/*#__PURE__*/react.forwardRef(CalendarOutlined_CalendarOutlined));
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons-svg/es/asn/ClockCircleOutlined.js
|
|
var asn_ClockCircleOutlined = __webpack_require__(99011);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/ClockCircleOutlined.js
|
|
|
|
// GENERATE BY ./scripts/generate.ts
|
|
// DON NOT EDIT IT MANUALLY
|
|
|
|
|
|
|
|
var ClockCircleOutlined = function ClockCircleOutlined(props, ref) {
|
|
return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
ref: ref,
|
|
icon: asn_ClockCircleOutlined/* default */.Z
|
|
}));
|
|
};
|
|
ClockCircleOutlined.displayName = 'ClockCircleOutlined';
|
|
/* harmony default export */ var icons_ClockCircleOutlined = (/*#__PURE__*/react.forwardRef(ClockCircleOutlined));
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/CloseCircleFilled.js
|
|
var CloseCircleFilled = __webpack_require__(17012);
|
|
;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/SwapRightOutlined.js
|
|
// This icon file is generated automatically.
|
|
var SwapRightOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "0 0 1024 1024", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M873.1 596.2l-164-208A32 32 0 00684 376h-64.8c-6.7 0-10.4 7.7-6.3 13l144.3 183H152c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h695.9c26.8 0 41.7-30.8 25.2-51.8z" } }] }, "name": "swap-right", "theme": "outlined" };
|
|
/* harmony default export */ var asn_SwapRightOutlined = (SwapRightOutlined);
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/SwapRightOutlined.js
|
|
|
|
// GENERATE BY ./scripts/generate.ts
|
|
// DON NOT EDIT IT MANUALLY
|
|
|
|
|
|
|
|
var SwapRightOutlined_SwapRightOutlined = function SwapRightOutlined(props, ref) {
|
|
return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
ref: ref,
|
|
icon: asn_SwapRightOutlined
|
|
}));
|
|
};
|
|
SwapRightOutlined_SwapRightOutlined.displayName = 'SwapRightOutlined';
|
|
/* harmony default export */ var icons_SwapRightOutlined = (/*#__PURE__*/react.forwardRef(SwapRightOutlined_SwapRightOutlined));
|
|
// 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/classCallCheck.js
|
|
var classCallCheck = __webpack_require__(15671);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
var createClass = __webpack_require__(43144);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
|
|
var inherits = __webpack_require__(60136);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js + 1 modules
|
|
var createSuper = __webpack_require__(51630);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMergedState.js
|
|
var useMergedState = __webpack_require__(21770);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/KeyCode.js
|
|
var KeyCode = __webpack_require__(15105);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/PanelContext.js
|
|
|
|
var PanelContext = /*#__PURE__*/react.createContext({});
|
|
/* harmony default export */ var es_PanelContext = (PanelContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/Header.js
|
|
|
|
|
|
var HIDDEN_STYLE = {
|
|
visibility: 'hidden'
|
|
};
|
|
function Header(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
_ref$prevIcon = _ref.prevIcon,
|
|
prevIcon = _ref$prevIcon === void 0 ? "\u2039" : _ref$prevIcon,
|
|
_ref$nextIcon = _ref.nextIcon,
|
|
nextIcon = _ref$nextIcon === void 0 ? "\u203A" : _ref$nextIcon,
|
|
_ref$superPrevIcon = _ref.superPrevIcon,
|
|
superPrevIcon = _ref$superPrevIcon === void 0 ? "\xAB" : _ref$superPrevIcon,
|
|
_ref$superNextIcon = _ref.superNextIcon,
|
|
superNextIcon = _ref$superNextIcon === void 0 ? "\xBB" : _ref$superNextIcon,
|
|
onSuperPrev = _ref.onSuperPrev,
|
|
onSuperNext = _ref.onSuperNext,
|
|
onPrev = _ref.onPrev,
|
|
onNext = _ref.onNext,
|
|
children = _ref.children;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideNextBtn = _React$useContext.hideNextBtn,
|
|
hidePrevBtn = _React$useContext.hidePrevBtn;
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: prefixCls
|
|
}, onSuperPrev && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onSuperPrev,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-super-prev-btn"),
|
|
style: hidePrevBtn ? HIDDEN_STYLE : {}
|
|
}, superPrevIcon), onPrev && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onPrev,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-prev-btn"),
|
|
style: hidePrevBtn ? HIDDEN_STYLE : {}
|
|
}, prevIcon), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-view")
|
|
}, children), onNext && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onNext,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-next-btn"),
|
|
style: hideNextBtn ? HIDDEN_STYLE : {}
|
|
}, nextIcon), onSuperNext && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onSuperNext,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-super-next-btn"),
|
|
style: hideNextBtn ? HIDDEN_STYLE : {}
|
|
}, superNextIcon));
|
|
}
|
|
/* harmony default export */ var panels_Header = (Header);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DecadePanel/DecadeHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function DecadeHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
viewDate = props.viewDate,
|
|
onPrevDecades = props.onPrevDecades,
|
|
onNextDecades = props.onNextDecades;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
var yearNumber = generateConfig.getYear(viewDate);
|
|
var startYear = Math.floor(yearNumber / DECADE_DISTANCE_COUNT) * DECADE_DISTANCE_COUNT;
|
|
var endYear = startYear + DECADE_DISTANCE_COUNT - 1;
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevDecades,
|
|
onSuperNext: onNextDecades
|
|
}), startYear, "-", endYear);
|
|
}
|
|
/* harmony default export */ var DecadePanel_DecadeHeader = (DecadeHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/timeUtil.js
|
|
function timeUtil_setTime(generateConfig, date, hour, minute, second) {
|
|
var nextTime = generateConfig.setHour(date, hour);
|
|
nextTime = generateConfig.setMinute(nextTime, minute);
|
|
nextTime = generateConfig.setSecond(nextTime, second);
|
|
return nextTime;
|
|
}
|
|
function setDateTime(generateConfig, date, defaultDate) {
|
|
if (!defaultDate) {
|
|
return date;
|
|
}
|
|
var newDate = date;
|
|
newDate = generateConfig.setHour(newDate, generateConfig.getHour(defaultDate));
|
|
newDate = generateConfig.setMinute(newDate, generateConfig.getMinute(defaultDate));
|
|
newDate = generateConfig.setSecond(newDate, generateConfig.getSecond(defaultDate));
|
|
return newDate;
|
|
}
|
|
function getLowerBoundTime(hour, minute, second, hourStep, minuteStep, secondStep) {
|
|
var lowerBoundHour = Math.floor(hour / hourStep) * hourStep;
|
|
if (lowerBoundHour < hour) {
|
|
return [lowerBoundHour, 60 - minuteStep, 60 - secondStep];
|
|
}
|
|
var lowerBoundMinute = Math.floor(minute / minuteStep) * minuteStep;
|
|
if (lowerBoundMinute < minute) {
|
|
return [lowerBoundHour, lowerBoundMinute, 60 - secondStep];
|
|
}
|
|
var lowerBoundSecond = Math.floor(second / secondStep) * secondStep;
|
|
return [lowerBoundHour, lowerBoundMinute, lowerBoundSecond];
|
|
}
|
|
function getLastDay(generateConfig, date) {
|
|
var year = generateConfig.getYear(date);
|
|
var month = generateConfig.getMonth(date) + 1;
|
|
var endDate = generateConfig.getEndDate(generateConfig.getFixedDate("".concat(year, "-").concat(month, "-01")));
|
|
var lastDay = generateConfig.getDate(endDate);
|
|
var monthShow = month < 10 ? "0".concat(month) : "".concat(month);
|
|
return "".concat(year, "-").concat(monthShow, "-").concat(lastDay);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/PanelBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function PanelBody(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
disabledDate = _ref.disabledDate,
|
|
onSelect = _ref.onSelect,
|
|
picker = _ref.picker,
|
|
rowNum = _ref.rowNum,
|
|
colNum = _ref.colNum,
|
|
prefixColumn = _ref.prefixColumn,
|
|
rowClassName = _ref.rowClassName,
|
|
baseDate = _ref.baseDate,
|
|
getCellClassName = _ref.getCellClassName,
|
|
getCellText = _ref.getCellText,
|
|
getCellNode = _ref.getCellNode,
|
|
getCellDate = _ref.getCellDate,
|
|
generateConfig = _ref.generateConfig,
|
|
titleCell = _ref.titleCell,
|
|
headerCells = _ref.headerCells;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
onDateMouseEnter = _React$useContext.onDateMouseEnter,
|
|
onDateMouseLeave = _React$useContext.onDateMouseLeave,
|
|
mode = _React$useContext.mode;
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
// =============================== Body ===============================
|
|
var rows = [];
|
|
for (var i = 0; i < rowNum; i += 1) {
|
|
var row = [];
|
|
var rowStartDate = void 0;
|
|
var _loop = function _loop(j) {
|
|
var _objectSpread2;
|
|
var offset = i * colNum + j;
|
|
var currentDate = getCellDate(baseDate, offset);
|
|
var disabled = getCellDateDisabled({
|
|
cellDate: currentDate,
|
|
mode: mode,
|
|
disabledDate: disabledDate,
|
|
generateConfig: generateConfig
|
|
});
|
|
if (j === 0) {
|
|
rowStartDate = currentDate;
|
|
if (prefixColumn) {
|
|
row.push(prefixColumn(rowStartDate));
|
|
}
|
|
}
|
|
var title = titleCell && titleCell(currentDate);
|
|
row.push( /*#__PURE__*/react.createElement("td", {
|
|
key: j,
|
|
title: title,
|
|
className: classnames_default()(cellPrefixCls, (0,objectSpread2/* default */.Z)((_objectSpread2 = {}, (0,defineProperty/* default */.Z)(_objectSpread2, "".concat(cellPrefixCls, "-disabled"), disabled), (0,defineProperty/* default */.Z)(_objectSpread2, "".concat(cellPrefixCls, "-start"), getCellText(currentDate) === 1 || picker === 'year' && Number(title) % 10 === 0), (0,defineProperty/* default */.Z)(_objectSpread2, "".concat(cellPrefixCls, "-end"), title === getLastDay(generateConfig, currentDate) || picker === 'year' && Number(title) % 10 === 9), _objectSpread2), getCellClassName(currentDate))),
|
|
onClick: function onClick() {
|
|
if (!disabled) {
|
|
onSelect(currentDate);
|
|
}
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
if (!disabled && onDateMouseEnter) {
|
|
onDateMouseEnter(currentDate);
|
|
}
|
|
},
|
|
onMouseLeave: function onMouseLeave() {
|
|
if (!disabled && onDateMouseLeave) {
|
|
onDateMouseLeave(currentDate);
|
|
}
|
|
}
|
|
}, getCellNode ? getCellNode(currentDate) : /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(cellPrefixCls, "-inner")
|
|
}, getCellText(currentDate))));
|
|
};
|
|
for (var j = 0; j < colNum; j += 1) {
|
|
_loop(j);
|
|
}
|
|
rows.push( /*#__PURE__*/react.createElement("tr", {
|
|
key: i,
|
|
className: rowClassName && rowClassName(rowStartDate)
|
|
}, row));
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-body")
|
|
}, /*#__PURE__*/react.createElement("table", {
|
|
className: "".concat(prefixCls, "-content")
|
|
}, headerCells && /*#__PURE__*/react.createElement("thead", null, /*#__PURE__*/react.createElement("tr", null, headerCells)), /*#__PURE__*/react.createElement("tbody", null, rows)));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DecadePanel/DecadeBody.js
|
|
|
|
|
|
|
|
|
|
|
|
var DECADE_COL_COUNT = 3;
|
|
var DECADE_ROW_COUNT = 4;
|
|
function DecadeBody(props) {
|
|
var DECADE_UNIT_DIFF_DES = DECADE_UNIT_DIFF - 1;
|
|
var prefixCls = props.prefixCls,
|
|
viewDate = props.viewDate,
|
|
generateConfig = props.generateConfig;
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var yearNumber = generateConfig.getYear(viewDate);
|
|
var decadeYearNumber = Math.floor(yearNumber / DECADE_UNIT_DIFF) * DECADE_UNIT_DIFF;
|
|
var startDecadeYear = Math.floor(yearNumber / DECADE_DISTANCE_COUNT) * DECADE_DISTANCE_COUNT;
|
|
var endDecadeYear = startDecadeYear + DECADE_DISTANCE_COUNT - 1;
|
|
var baseDecadeYear = generateConfig.setYear(viewDate, startDecadeYear - Math.ceil((DECADE_COL_COUNT * DECADE_ROW_COUNT * DECADE_UNIT_DIFF - DECADE_DISTANCE_COUNT) / 2));
|
|
var getCellClassName = function getCellClassName(date) {
|
|
var _ref;
|
|
var startDecadeNumber = generateConfig.getYear(date);
|
|
var endDecadeNumber = startDecadeNumber + DECADE_UNIT_DIFF_DES;
|
|
return _ref = {}, (0,defineProperty/* default */.Z)(_ref, "".concat(cellPrefixCls, "-in-view"), startDecadeYear <= startDecadeNumber && endDecadeNumber <= endDecadeYear), (0,defineProperty/* default */.Z)(_ref, "".concat(cellPrefixCls, "-selected"), startDecadeNumber === decadeYearNumber), _ref;
|
|
};
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: DECADE_ROW_COUNT,
|
|
colNum: DECADE_COL_COUNT,
|
|
baseDate: baseDecadeYear,
|
|
getCellText: function getCellText(date) {
|
|
var startDecadeNumber = generateConfig.getYear(date);
|
|
return "".concat(startDecadeNumber, "-").concat(startDecadeNumber + DECADE_UNIT_DIFF_DES);
|
|
},
|
|
getCellClassName: getCellClassName,
|
|
getCellDate: function getCellDate(date, offset) {
|
|
return generateConfig.addYear(date, offset * DECADE_UNIT_DIFF);
|
|
}
|
|
}));
|
|
}
|
|
/* harmony default export */ var DecadePanel_DecadeBody = (DecadeBody);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(74902);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/raf.js
|
|
var raf = __webpack_require__(75164);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Dom/isVisible.js
|
|
var isVisible = __webpack_require__(5110);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/uiUtil.js
|
|
|
|
|
|
|
|
|
|
var scrollIds = new Map();
|
|
/** Trigger when element is visible in view */
|
|
function waitElementReady(element, callback) {
|
|
var id;
|
|
function tryOrNextFrame() {
|
|
if ((0,isVisible/* default */.Z)(element)) {
|
|
callback();
|
|
} else {
|
|
id = (0,raf/* default */.Z)(function () {
|
|
tryOrNextFrame();
|
|
});
|
|
}
|
|
}
|
|
tryOrNextFrame();
|
|
return function () {
|
|
raf/* default.cancel */.Z.cancel(id);
|
|
};
|
|
}
|
|
/* eslint-disable no-param-reassign */
|
|
function scrollTo(element, to, duration) {
|
|
if (scrollIds.get(element)) {
|
|
cancelAnimationFrame(scrollIds.get(element));
|
|
}
|
|
// jump to target if duration zero
|
|
if (duration <= 0) {
|
|
scrollIds.set(element, requestAnimationFrame(function () {
|
|
element.scrollTop = to;
|
|
}));
|
|
return;
|
|
}
|
|
var difference = to - element.scrollTop;
|
|
var perTick = difference / duration * 10;
|
|
scrollIds.set(element, requestAnimationFrame(function () {
|
|
element.scrollTop += perTick;
|
|
if (element.scrollTop !== to) {
|
|
scrollTo(element, to, duration - 10);
|
|
}
|
|
}));
|
|
}
|
|
function createKeyDownHandler(event, _ref) {
|
|
var onLeftRight = _ref.onLeftRight,
|
|
onCtrlLeftRight = _ref.onCtrlLeftRight,
|
|
onUpDown = _ref.onUpDown,
|
|
onPageUpDown = _ref.onPageUpDown,
|
|
onEnter = _ref.onEnter;
|
|
var which = event.which,
|
|
ctrlKey = event.ctrlKey,
|
|
metaKey = event.metaKey;
|
|
switch (which) {
|
|
case KeyCode/* default.LEFT */.Z.LEFT:
|
|
if (ctrlKey || metaKey) {
|
|
if (onCtrlLeftRight) {
|
|
onCtrlLeftRight(-1);
|
|
return true;
|
|
}
|
|
} else if (onLeftRight) {
|
|
onLeftRight(-1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case KeyCode/* default.RIGHT */.Z.RIGHT:
|
|
if (ctrlKey || metaKey) {
|
|
if (onCtrlLeftRight) {
|
|
onCtrlLeftRight(1);
|
|
return true;
|
|
}
|
|
} else if (onLeftRight) {
|
|
onLeftRight(1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case KeyCode/* default.UP */.Z.UP:
|
|
if (onUpDown) {
|
|
onUpDown(-1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case KeyCode/* default.DOWN */.Z.DOWN:
|
|
if (onUpDown) {
|
|
onUpDown(1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case KeyCode/* default.PAGE_UP */.Z.PAGE_UP:
|
|
if (onPageUpDown) {
|
|
onPageUpDown(-1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case KeyCode/* default.PAGE_DOWN */.Z.PAGE_DOWN:
|
|
if (onPageUpDown) {
|
|
onPageUpDown(1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case KeyCode/* default.ENTER */.Z.ENTER:
|
|
if (onEnter) {
|
|
onEnter();
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
// ===================== Format =====================
|
|
function getDefaultFormat(format, picker, showTime, use12Hours) {
|
|
var mergedFormat = format;
|
|
if (!mergedFormat) {
|
|
switch (picker) {
|
|
case 'time':
|
|
mergedFormat = use12Hours ? 'hh:mm:ss a' : 'HH:mm:ss';
|
|
break;
|
|
case 'week':
|
|
mergedFormat = 'gggg-wo';
|
|
break;
|
|
case 'month':
|
|
mergedFormat = 'YYYY-MM';
|
|
break;
|
|
case 'quarter':
|
|
mergedFormat = 'YYYY-[Q]Q';
|
|
break;
|
|
case 'year':
|
|
mergedFormat = 'YYYY';
|
|
break;
|
|
default:
|
|
mergedFormat = showTime ? 'YYYY-MM-DD HH:mm:ss' : 'YYYY-MM-DD';
|
|
}
|
|
}
|
|
return mergedFormat;
|
|
}
|
|
function getInputSize(picker, format, generateConfig) {
|
|
var defaultSize = picker === 'time' ? 8 : 10;
|
|
var length = typeof format === 'function' ? format(generateConfig.getNow()).length : format.length;
|
|
return Math.max(defaultSize, length) + 2;
|
|
}
|
|
var globalClickFunc = null;
|
|
var clickCallbacks = new Set();
|
|
function addGlobalMouseDownEvent(callback) {
|
|
if (!globalClickFunc && typeof window !== 'undefined' && window.addEventListener) {
|
|
globalClickFunc = function globalClickFunc(e) {
|
|
// Clone a new list to avoid repeat trigger events
|
|
(0,toConsumableArray/* default */.Z)(clickCallbacks).forEach(function (queueFunc) {
|
|
queueFunc(e);
|
|
});
|
|
};
|
|
window.addEventListener('mousedown', globalClickFunc);
|
|
}
|
|
clickCallbacks.add(callback);
|
|
return function () {
|
|
clickCallbacks.delete(callback);
|
|
if (clickCallbacks.size === 0) {
|
|
window.removeEventListener('mousedown', globalClickFunc);
|
|
globalClickFunc = null;
|
|
}
|
|
};
|
|
}
|
|
function getTargetFromEvent(e) {
|
|
var target = e.target;
|
|
// get target if in shadow dom
|
|
if (e.composed && target.shadowRoot) {
|
|
var _e$composedPath;
|
|
return ((_e$composedPath = e.composedPath) === null || _e$composedPath === void 0 ? void 0 : _e$composedPath.call(e)[0]) || target;
|
|
}
|
|
return target;
|
|
}
|
|
// ====================== Mode ======================
|
|
var getYearNextMode = function getYearNextMode(next) {
|
|
if (next === 'month' || next === 'date') {
|
|
return 'year';
|
|
}
|
|
return next;
|
|
};
|
|
var getMonthNextMode = function getMonthNextMode(next) {
|
|
if (next === 'date') {
|
|
return 'month';
|
|
}
|
|
return next;
|
|
};
|
|
var getQuarterNextMode = function getQuarterNextMode(next) {
|
|
if (next === 'month' || next === 'date') {
|
|
return 'quarter';
|
|
}
|
|
return next;
|
|
};
|
|
var getWeekNextMode = function getWeekNextMode(next) {
|
|
if (next === 'date') {
|
|
return 'week';
|
|
}
|
|
return next;
|
|
};
|
|
var PickerModeMap = {
|
|
year: getYearNextMode,
|
|
month: getMonthNextMode,
|
|
quarter: getQuarterNextMode,
|
|
week: getWeekNextMode,
|
|
time: null,
|
|
date: null
|
|
};
|
|
function elementsContains(elements, target) {
|
|
return elements.some(function (ele) {
|
|
return ele && ele.contains(target);
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DecadePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
var DECADE_UNIT_DIFF = 10;
|
|
var DECADE_DISTANCE_COUNT = DECADE_UNIT_DIFF * 10;
|
|
function DecadePanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
onViewDateChange = props.onViewDateChange,
|
|
generateConfig = props.generateConfig,
|
|
viewDate = props.viewDate,
|
|
operationRef = props.operationRef,
|
|
onSelect = props.onSelect,
|
|
onPanelChange = props.onPanelChange;
|
|
var panelPrefixCls = "".concat(prefixCls, "-decade-panel");
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
onSelect(generateConfig.addYear(viewDate, diff * DECADE_UNIT_DIFF), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
onSelect(generateConfig.addYear(viewDate, diff * DECADE_DISTANCE_COUNT), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
onSelect(generateConfig.addYear(viewDate, diff * DECADE_UNIT_DIFF * DECADE_COL_COUNT), 'key');
|
|
},
|
|
onEnter: function onEnter() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
// ==================== View Operation ====================
|
|
var onDecadesChange = function onDecadesChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff * DECADE_DISTANCE_COUNT);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
var onInternalSelect = function onInternalSelect(date) {
|
|
onSelect(date, 'mouse');
|
|
onPanelChange('year', date);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: panelPrefixCls
|
|
}, /*#__PURE__*/react.createElement(DecadePanel_DecadeHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onPrevDecades: function onPrevDecades() {
|
|
onDecadesChange(-1);
|
|
},
|
|
onNextDecades: function onNextDecades() {
|
|
onDecadesChange(1);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(DecadePanel_DecadeBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onSelect: onInternalSelect
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_DecadePanel = (DecadePanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/dateUtil.js
|
|
|
|
var WEEK_DAY_COUNT = 7;
|
|
function isNullEqual(value1, value2) {
|
|
if (!value1 && !value2) {
|
|
return true;
|
|
}
|
|
if (!value1 || !value2) {
|
|
return false;
|
|
}
|
|
return undefined;
|
|
}
|
|
function isSameDecade(generateConfig, decade1, decade2) {
|
|
var equal = isNullEqual(decade1, decade2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
var num1 = Math.floor(generateConfig.getYear(decade1) / 10);
|
|
var num2 = Math.floor(generateConfig.getYear(decade2) / 10);
|
|
return num1 === num2;
|
|
}
|
|
function isSameYear(generateConfig, year1, year2) {
|
|
var equal = isNullEqual(year1, year2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.getYear(year1) === generateConfig.getYear(year2);
|
|
}
|
|
function getQuarter(generateConfig, date) {
|
|
var quota = Math.floor(generateConfig.getMonth(date) / 3);
|
|
return quota + 1;
|
|
}
|
|
function isSameQuarter(generateConfig, quarter1, quarter2) {
|
|
var equal = isNullEqual(quarter1, quarter2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return isSameYear(generateConfig, quarter1, quarter2) && getQuarter(generateConfig, quarter1) === getQuarter(generateConfig, quarter2);
|
|
}
|
|
function isSameMonth(generateConfig, month1, month2) {
|
|
var equal = isNullEqual(month1, month2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return isSameYear(generateConfig, month1, month2) && generateConfig.getMonth(month1) === generateConfig.getMonth(month2);
|
|
}
|
|
function isSameDate(generateConfig, date1, date2) {
|
|
var equal = isNullEqual(date1, date2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.getYear(date1) === generateConfig.getYear(date2) && generateConfig.getMonth(date1) === generateConfig.getMonth(date2) && generateConfig.getDate(date1) === generateConfig.getDate(date2);
|
|
}
|
|
function isSameTime(generateConfig, time1, time2) {
|
|
var equal = isNullEqual(time1, time2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.getHour(time1) === generateConfig.getHour(time2) && generateConfig.getMinute(time1) === generateConfig.getMinute(time2) && generateConfig.getSecond(time1) === generateConfig.getSecond(time2);
|
|
}
|
|
function isSameWeek(generateConfig, locale, date1, date2) {
|
|
var equal = isNullEqual(date1, date2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.locale.getWeek(locale, date1) === generateConfig.locale.getWeek(locale, date2);
|
|
}
|
|
function isEqual(generateConfig, value1, value2) {
|
|
return isSameDate(generateConfig, value1, value2) && isSameTime(generateConfig, value1, value2);
|
|
}
|
|
/** Between in date but not equal of date */
|
|
function isInRange(generateConfig, startDate, endDate, current) {
|
|
if (!startDate || !endDate || !current) {
|
|
return false;
|
|
}
|
|
return !isSameDate(generateConfig, startDate, current) && !isSameDate(generateConfig, endDate, current) && generateConfig.isAfter(current, startDate) && generateConfig.isAfter(endDate, current);
|
|
}
|
|
function getWeekStartDate(locale, generateConfig, value) {
|
|
var weekFirstDay = generateConfig.locale.getWeekFirstDay(locale);
|
|
var monthStartDate = generateConfig.setDate(value, 1);
|
|
var startDateWeekDay = generateConfig.getWeekDay(monthStartDate);
|
|
var alignStartDate = generateConfig.addDate(monthStartDate, weekFirstDay - startDateWeekDay);
|
|
if (generateConfig.getMonth(alignStartDate) === generateConfig.getMonth(value) && generateConfig.getDate(alignStartDate) > 1) {
|
|
alignStartDate = generateConfig.addDate(alignStartDate, -7);
|
|
}
|
|
return alignStartDate;
|
|
}
|
|
function getClosingViewDate(viewDate, picker, generateConfig) {
|
|
var offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
|
|
switch (picker) {
|
|
case 'year':
|
|
return generateConfig.addYear(viewDate, offset * 10);
|
|
case 'quarter':
|
|
case 'month':
|
|
return generateConfig.addYear(viewDate, offset);
|
|
default:
|
|
return generateConfig.addMonth(viewDate, offset);
|
|
}
|
|
}
|
|
function formatValue(value, _ref) {
|
|
var generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale,
|
|
format = _ref.format;
|
|
return typeof format === 'function' ? format(value) : generateConfig.locale.format(locale.locale, value, format);
|
|
}
|
|
function parseValue(value, _ref2) {
|
|
var generateConfig = _ref2.generateConfig,
|
|
locale = _ref2.locale,
|
|
formatList = _ref2.formatList;
|
|
if (!value || typeof formatList[0] === 'function') {
|
|
return null;
|
|
}
|
|
return generateConfig.locale.parse(locale.locale, value, formatList);
|
|
}
|
|
// eslint-disable-next-line consistent-return
|
|
function getCellDateDisabled(_ref3) {
|
|
var cellDate = _ref3.cellDate,
|
|
mode = _ref3.mode,
|
|
disabledDate = _ref3.disabledDate,
|
|
generateConfig = _ref3.generateConfig;
|
|
if (!disabledDate) return false;
|
|
// Whether cellDate is disabled in range
|
|
var getDisabledFromRange = function getDisabledFromRange(currentMode, start, end) {
|
|
var current = start;
|
|
while (current <= end) {
|
|
var date = void 0;
|
|
switch (currentMode) {
|
|
case 'date':
|
|
{
|
|
date = generateConfig.setDate(cellDate, current);
|
|
if (!disabledDate(date)) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case 'month':
|
|
{
|
|
date = generateConfig.setMonth(cellDate, current);
|
|
if (!getCellDateDisabled({
|
|
cellDate: date,
|
|
mode: 'month',
|
|
generateConfig: generateConfig,
|
|
disabledDate: disabledDate
|
|
})) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case 'year':
|
|
{
|
|
date = generateConfig.setYear(cellDate, current);
|
|
if (!getCellDateDisabled({
|
|
cellDate: date,
|
|
mode: 'year',
|
|
generateConfig: generateConfig,
|
|
disabledDate: disabledDate
|
|
})) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
current += 1;
|
|
}
|
|
return true;
|
|
};
|
|
switch (mode) {
|
|
case 'date':
|
|
case 'week':
|
|
{
|
|
return disabledDate(cellDate);
|
|
}
|
|
case 'month':
|
|
{
|
|
var startDate = 1;
|
|
var endDate = generateConfig.getDate(generateConfig.getEndDate(cellDate));
|
|
return getDisabledFromRange('date', startDate, endDate);
|
|
}
|
|
case 'quarter':
|
|
{
|
|
var startMonth = Math.floor(generateConfig.getMonth(cellDate) / 3) * 3;
|
|
var endMonth = startMonth + 2;
|
|
return getDisabledFromRange('month', startMonth, endMonth);
|
|
}
|
|
case 'year':
|
|
{
|
|
return getDisabledFromRange('month', 0, 11);
|
|
}
|
|
case 'decade':
|
|
{
|
|
var year = generateConfig.getYear(cellDate);
|
|
var startYear = Math.floor(year / DECADE_UNIT_DIFF) * DECADE_UNIT_DIFF;
|
|
var endYear = startYear + DECADE_UNIT_DIFF - 1;
|
|
return getDisabledFromRange('year', startYear, endYear);
|
|
}
|
|
}
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/TimePanel/TimeHeader.js
|
|
|
|
|
|
|
|
|
|
function TimeHeader(props) {
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
value = props.value,
|
|
format = props.format;
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
return /*#__PURE__*/react.createElement(panels_Header, {
|
|
prefixCls: headerPrefixCls
|
|
}, value ? formatValue(value, {
|
|
locale: locale,
|
|
format: format,
|
|
generateConfig: generateConfig
|
|
}) : "\xA0");
|
|
}
|
|
/* harmony default export */ var TimePanel_TimeHeader = (TimeHeader);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useMemo.js
|
|
var useMemo = __webpack_require__(56982);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/TimePanel/TimeUnitColumn.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function TimeUnitColumn(props) {
|
|
var prefixCls = props.prefixCls,
|
|
units = props.units,
|
|
onSelect = props.onSelect,
|
|
value = props.value,
|
|
active = props.active,
|
|
hideDisabledOptions = props.hideDisabledOptions;
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
open = _React$useContext.open;
|
|
var ulRef = (0,react.useRef)(null);
|
|
var liRefs = (0,react.useRef)(new Map());
|
|
var scrollRef = (0,react.useRef)();
|
|
// `useLayoutEffect` here to avoid blink by duration is 0
|
|
(0,react.useLayoutEffect)(function () {
|
|
var li = liRefs.current.get(value);
|
|
if (li && open !== false) {
|
|
scrollTo(ulRef.current, li.offsetTop, 120);
|
|
}
|
|
}, [value]);
|
|
(0,react.useLayoutEffect)(function () {
|
|
if (open) {
|
|
var li = liRefs.current.get(value);
|
|
if (li) {
|
|
scrollRef.current = waitElementReady(li, function () {
|
|
scrollTo(ulRef.current, li.offsetTop, 0);
|
|
});
|
|
}
|
|
}
|
|
return function () {
|
|
var _scrollRef$current;
|
|
(_scrollRef$current = scrollRef.current) === null || _scrollRef$current === void 0 ? void 0 : _scrollRef$current.call(scrollRef);
|
|
};
|
|
}, [open]);
|
|
return /*#__PURE__*/react.createElement("ul", {
|
|
className: classnames_default()("".concat(prefixCls, "-column"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-column-active"), active)),
|
|
ref: ulRef,
|
|
style: {
|
|
position: 'relative'
|
|
}
|
|
}, units.map(function (unit) {
|
|
var _classNames2;
|
|
if (hideDisabledOptions && unit.disabled) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement("li", {
|
|
key: unit.value,
|
|
ref: function ref(element) {
|
|
liRefs.current.set(unit.value, element);
|
|
},
|
|
className: classnames_default()(cellPrefixCls, (_classNames2 = {}, (0,defineProperty/* default */.Z)(_classNames2, "".concat(cellPrefixCls, "-disabled"), unit.disabled), (0,defineProperty/* default */.Z)(_classNames2, "".concat(cellPrefixCls, "-selected"), value === unit.value), _classNames2)),
|
|
onClick: function onClick() {
|
|
if (unit.disabled) {
|
|
return;
|
|
}
|
|
onSelect(unit.value);
|
|
}
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(cellPrefixCls, "-inner")
|
|
}, unit.label));
|
|
}));
|
|
}
|
|
/* harmony default export */ var TimePanel_TimeUnitColumn = (TimeUnitColumn);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/miscUtil.js
|
|
function leftPad(str, length) {
|
|
var fill = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
|
|
var current = String(str);
|
|
while (current.length < length) {
|
|
current = "".concat(fill).concat(str);
|
|
}
|
|
return current;
|
|
}
|
|
var tuple = function tuple() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
return args;
|
|
};
|
|
function toArray(val) {
|
|
if (val === null || val === undefined) {
|
|
return [];
|
|
}
|
|
return Array.isArray(val) ? val : [val];
|
|
}
|
|
function getDataOrAriaProps(props) {
|
|
var retProps = {};
|
|
Object.keys(props).forEach(function (key) {
|
|
if ((key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-' || key === 'role' || key === 'name') && key.substr(0, 7) !== 'data-__') {
|
|
retProps[key] = props[key];
|
|
}
|
|
});
|
|
return retProps;
|
|
}
|
|
function getValue(values, index) {
|
|
return values ? values[index] : null;
|
|
}
|
|
function updateValues(values, value, index) {
|
|
var newValues = [getValue(values, 0), getValue(values, 1)];
|
|
newValues[index] = typeof value === 'function' ? value(newValues[index]) : value;
|
|
if (!newValues[0] && !newValues[1]) {
|
|
return null;
|
|
}
|
|
return newValues;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/TimePanel/TimeBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function shouldUnitsUpdate(prevUnits, nextUnits) {
|
|
if (prevUnits.length !== nextUnits.length) return true;
|
|
// if any unit's disabled status is different, the units should be re-evaluted
|
|
for (var i = 0; i < prevUnits.length; i += 1) {
|
|
if (prevUnits[i].disabled !== nextUnits[i].disabled) return true;
|
|
}
|
|
return false;
|
|
}
|
|
function generateUnits(start, end, step, disabledUnits) {
|
|
var units = [];
|
|
for (var i = start; i <= end; i += step) {
|
|
units.push({
|
|
label: leftPad(i, 2),
|
|
value: i,
|
|
disabled: (disabledUnits || []).includes(i)
|
|
});
|
|
}
|
|
return units;
|
|
}
|
|
function TimeBody(props) {
|
|
var generateConfig = props.generateConfig,
|
|
prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
activeColumnIndex = props.activeColumnIndex,
|
|
value = props.value,
|
|
showHour = props.showHour,
|
|
showMinute = props.showMinute,
|
|
showSecond = props.showSecond,
|
|
use12Hours = props.use12Hours,
|
|
_props$hourStep = props.hourStep,
|
|
hourStep = _props$hourStep === void 0 ? 1 : _props$hourStep,
|
|
_props$minuteStep = props.minuteStep,
|
|
minuteStep = _props$minuteStep === void 0 ? 1 : _props$minuteStep,
|
|
_props$secondStep = props.secondStep,
|
|
secondStep = _props$secondStep === void 0 ? 1 : _props$secondStep,
|
|
disabledHours = props.disabledHours,
|
|
disabledMinutes = props.disabledMinutes,
|
|
disabledSeconds = props.disabledSeconds,
|
|
disabledTime = props.disabledTime,
|
|
hideDisabledOptions = props.hideDisabledOptions,
|
|
onSelect = props.onSelect;
|
|
// Misc
|
|
var columns = [];
|
|
var contentPrefixCls = "".concat(prefixCls, "-content");
|
|
var columnPrefixCls = "".concat(prefixCls, "-time-panel");
|
|
var isPM;
|
|
var originHour = value ? generateConfig.getHour(value) : -1;
|
|
var hour = originHour;
|
|
var minute = value ? generateConfig.getMinute(value) : -1;
|
|
var second = value ? generateConfig.getSecond(value) : -1;
|
|
// Disabled Time
|
|
var now = generateConfig.getNow();
|
|
var _React$useMemo = react.useMemo(function () {
|
|
if (disabledTime) {
|
|
var disabledConfig = disabledTime(now);
|
|
return [disabledConfig.disabledHours, disabledConfig.disabledMinutes, disabledConfig.disabledSeconds];
|
|
}
|
|
return [disabledHours, disabledMinutes, disabledSeconds];
|
|
}, [disabledHours, disabledMinutes, disabledSeconds, disabledTime, now]),
|
|
_React$useMemo2 = (0,slicedToArray/* default */.Z)(_React$useMemo, 3),
|
|
mergedDisabledHours = _React$useMemo2[0],
|
|
mergedDisabledMinutes = _React$useMemo2[1],
|
|
mergedDisabledSeconds = _React$useMemo2[2];
|
|
// Set Time
|
|
var setTime = function setTime(isNewPM, newHour, newMinute, newSecond) {
|
|
var newDate = value || generateConfig.getNow();
|
|
var mergedHour = Math.max(0, newHour);
|
|
var mergedMinute = Math.max(0, newMinute);
|
|
var mergedSecond = Math.max(0, newSecond);
|
|
newDate = timeUtil_setTime(generateConfig, newDate, !use12Hours || !isNewPM ? mergedHour : mergedHour + 12, mergedMinute, mergedSecond);
|
|
return newDate;
|
|
};
|
|
// ========================= Unit =========================
|
|
var rawHours = generateUnits(0, 23, hourStep, mergedDisabledHours && mergedDisabledHours());
|
|
var memorizedRawHours = (0,useMemo/* default */.Z)(function () {
|
|
return rawHours;
|
|
}, rawHours, shouldUnitsUpdate);
|
|
// Should additional logic to handle 12 hours
|
|
if (use12Hours) {
|
|
isPM = hour >= 12; // -1 means should display AM
|
|
hour %= 12;
|
|
}
|
|
var _React$useMemo3 = react.useMemo(function () {
|
|
if (!use12Hours) {
|
|
return [false, false];
|
|
}
|
|
var AMPMDisabled = [true, true];
|
|
memorizedRawHours.forEach(function (_ref) {
|
|
var disabled = _ref.disabled,
|
|
hourValue = _ref.value;
|
|
if (disabled) return;
|
|
if (hourValue >= 12) {
|
|
AMPMDisabled[1] = false;
|
|
} else {
|
|
AMPMDisabled[0] = false;
|
|
}
|
|
});
|
|
return AMPMDisabled;
|
|
}, [use12Hours, memorizedRawHours]),
|
|
_React$useMemo4 = (0,slicedToArray/* default */.Z)(_React$useMemo3, 2),
|
|
AMDisabled = _React$useMemo4[0],
|
|
PMDisabled = _React$useMemo4[1];
|
|
var hours = react.useMemo(function () {
|
|
if (!use12Hours) return memorizedRawHours;
|
|
return memorizedRawHours.filter(isPM ? function (hourMeta) {
|
|
return hourMeta.value >= 12;
|
|
} : function (hourMeta) {
|
|
return hourMeta.value < 12;
|
|
}).map(function (hourMeta) {
|
|
var hourValue = hourMeta.value % 12;
|
|
var hourLabel = hourValue === 0 ? '12' : leftPad(hourValue, 2);
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, hourMeta), {}, {
|
|
label: hourLabel,
|
|
value: hourValue
|
|
});
|
|
});
|
|
}, [use12Hours, isPM, memorizedRawHours]);
|
|
var minutes = generateUnits(0, 59, minuteStep, mergedDisabledMinutes && mergedDisabledMinutes(originHour));
|
|
var seconds = generateUnits(0, 59, secondStep, mergedDisabledSeconds && mergedDisabledSeconds(originHour, minute));
|
|
// ====================== Operations ======================
|
|
operationRef.current = {
|
|
onUpDown: function onUpDown(diff) {
|
|
var column = columns[activeColumnIndex];
|
|
if (column) {
|
|
var valueIndex = column.units.findIndex(function (unit) {
|
|
return unit.value === column.value;
|
|
});
|
|
var unitLen = column.units.length;
|
|
for (var i = 1; i < unitLen; i += 1) {
|
|
var nextUnit = column.units[(valueIndex + diff * i + unitLen) % unitLen];
|
|
if (nextUnit.disabled !== true) {
|
|
column.onSelect(nextUnit.value);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
// ======================== Render ========================
|
|
function addColumnNode(condition, node, columnValue, units, onColumnSelect) {
|
|
if (condition !== false) {
|
|
columns.push({
|
|
node: /*#__PURE__*/react.cloneElement(node, {
|
|
prefixCls: columnPrefixCls,
|
|
value: columnValue,
|
|
active: activeColumnIndex === columns.length,
|
|
onSelect: onColumnSelect,
|
|
units: units,
|
|
hideDisabledOptions: hideDisabledOptions
|
|
}),
|
|
onSelect: onColumnSelect,
|
|
value: columnValue,
|
|
units: units
|
|
});
|
|
}
|
|
}
|
|
// Hour
|
|
addColumnNode(showHour, /*#__PURE__*/react.createElement(TimePanel_TimeUnitColumn, {
|
|
key: "hour"
|
|
}), hour, hours, function (num) {
|
|
onSelect(setTime(isPM, num, minute, second), 'mouse');
|
|
});
|
|
// Minute
|
|
addColumnNode(showMinute, /*#__PURE__*/react.createElement(TimePanel_TimeUnitColumn, {
|
|
key: "minute"
|
|
}), minute, minutes, function (num) {
|
|
onSelect(setTime(isPM, hour, num, second), 'mouse');
|
|
});
|
|
// Second
|
|
addColumnNode(showSecond, /*#__PURE__*/react.createElement(TimePanel_TimeUnitColumn, {
|
|
key: "second"
|
|
}), second, seconds, function (num) {
|
|
onSelect(setTime(isPM, hour, minute, num), 'mouse');
|
|
});
|
|
// 12 Hours
|
|
var PMIndex = -1;
|
|
if (typeof isPM === 'boolean') {
|
|
PMIndex = isPM ? 1 : 0;
|
|
}
|
|
addColumnNode(use12Hours === true, /*#__PURE__*/react.createElement(TimePanel_TimeUnitColumn, {
|
|
key: "12hours"
|
|
}), PMIndex, [{
|
|
label: 'AM',
|
|
value: 0,
|
|
disabled: AMDisabled
|
|
}, {
|
|
label: 'PM',
|
|
value: 1,
|
|
disabled: PMDisabled
|
|
}], function (num) {
|
|
onSelect(setTime(!!num, hour, minute, second), 'mouse');
|
|
});
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: contentPrefixCls
|
|
}, columns.map(function (_ref2) {
|
|
var node = _ref2.node;
|
|
return node;
|
|
}));
|
|
}
|
|
/* harmony default export */ var TimePanel_TimeBody = (TimeBody);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/TimePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var countBoolean = function countBoolean(boolList) {
|
|
return boolList.filter(function (bool) {
|
|
return bool !== false;
|
|
}).length;
|
|
};
|
|
function TimePanel(props) {
|
|
var generateConfig = props.generateConfig,
|
|
_props$format = props.format,
|
|
format = _props$format === void 0 ? 'HH:mm:ss' : _props$format,
|
|
prefixCls = props.prefixCls,
|
|
active = props.active,
|
|
operationRef = props.operationRef,
|
|
showHour = props.showHour,
|
|
showMinute = props.showMinute,
|
|
showSecond = props.showSecond,
|
|
_props$use12Hours = props.use12Hours,
|
|
use12Hours = _props$use12Hours === void 0 ? false : _props$use12Hours,
|
|
onSelect = props.onSelect,
|
|
value = props.value;
|
|
var panelPrefixCls = "".concat(prefixCls, "-time-panel");
|
|
var bodyOperationRef = react.useRef();
|
|
// ======================= Keyboard =======================
|
|
var _React$useState = react.useState(-1),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activeColumnIndex = _React$useState2[0],
|
|
setActiveColumnIndex = _React$useState2[1];
|
|
var columnsCount = countBoolean([showHour, showMinute, showSecond, use12Hours]);
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
setActiveColumnIndex((activeColumnIndex + diff + columnsCount) % columnsCount);
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
if (activeColumnIndex === -1) {
|
|
setActiveColumnIndex(0);
|
|
} else if (bodyOperationRef.current) {
|
|
bodyOperationRef.current.onUpDown(diff);
|
|
}
|
|
},
|
|
onEnter: function onEnter() {
|
|
onSelect(value || generateConfig.getNow(), 'key');
|
|
setActiveColumnIndex(-1);
|
|
}
|
|
});
|
|
},
|
|
onBlur: function onBlur() {
|
|
setActiveColumnIndex(-1);
|
|
}
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(panelPrefixCls, (0,defineProperty/* default */.Z)({}, "".concat(panelPrefixCls, "-active"), active))
|
|
}, /*#__PURE__*/react.createElement(TimePanel_TimeHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
format: format,
|
|
prefixCls: prefixCls
|
|
})), /*#__PURE__*/react.createElement(TimePanel_TimeBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
activeColumnIndex: activeColumnIndex,
|
|
operationRef: bodyOperationRef
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_TimePanel = (TimePanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/RangeContext.js
|
|
|
|
var RangeContext = /*#__PURE__*/react.createContext({});
|
|
/* harmony default export */ var es_RangeContext = (RangeContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useCellClassName.js
|
|
|
|
|
|
|
|
function useCellClassName(_ref) {
|
|
var cellPrefixCls = _ref.cellPrefixCls,
|
|
generateConfig = _ref.generateConfig,
|
|
rangedValue = _ref.rangedValue,
|
|
hoverRangedValue = _ref.hoverRangedValue,
|
|
isInView = _ref.isInView,
|
|
isSameCell = _ref.isSameCell,
|
|
offsetCell = _ref.offsetCell,
|
|
today = _ref.today,
|
|
value = _ref.value;
|
|
function getClassName(currentDate) {
|
|
var _ref2;
|
|
var prevDate = offsetCell(currentDate, -1);
|
|
var nextDate = offsetCell(currentDate, 1);
|
|
var rangeStart = getValue(rangedValue, 0);
|
|
var rangeEnd = getValue(rangedValue, 1);
|
|
var hoverStart = getValue(hoverRangedValue, 0);
|
|
var hoverEnd = getValue(hoverRangedValue, 1);
|
|
var isRangeHovered = isInRange(generateConfig, hoverStart, hoverEnd, currentDate);
|
|
function isRangeStart(date) {
|
|
return isSameCell(rangeStart, date);
|
|
}
|
|
function isRangeEnd(date) {
|
|
return isSameCell(rangeEnd, date);
|
|
}
|
|
var isHoverStart = isSameCell(hoverStart, currentDate);
|
|
var isHoverEnd = isSameCell(hoverEnd, currentDate);
|
|
var isHoverEdgeStart = (isRangeHovered || isHoverEnd) && (!isInView(prevDate) || isRangeEnd(prevDate));
|
|
var isHoverEdgeEnd = (isRangeHovered || isHoverStart) && (!isInView(nextDate) || isRangeStart(nextDate));
|
|
return _ref2 = {}, (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-in-view"), isInView(currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-in-range"), isInRange(generateConfig, rangeStart, rangeEnd, currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-start"), isRangeStart(currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-end"), isRangeEnd(currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-start-single"), isRangeStart(currentDate) && !rangeEnd), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-end-single"), isRangeEnd(currentDate) && !rangeStart), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-start-near-hover"), isRangeStart(currentDate) && (isSameCell(prevDate, hoverStart) || isInRange(generateConfig, hoverStart, hoverEnd, prevDate))), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-end-near-hover"), isRangeEnd(currentDate) && (isSameCell(nextDate, hoverEnd) || isInRange(generateConfig, hoverStart, hoverEnd, nextDate))), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover"), isRangeHovered), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-start"), isHoverStart), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-end"), isHoverEnd), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-start"), isHoverEdgeStart), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-end"), isHoverEdgeEnd), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-start-near-range"), isHoverEdgeStart && isSameCell(prevDate, rangeEnd)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-end-near-range"), isHoverEdgeEnd && isSameCell(nextDate, rangeStart)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-today"), isSameCell(today, currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-selected"), isSameCell(value, currentDate)), _ref2;
|
|
}
|
|
return getClassName;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DatePanel/DateBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function DateBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
prefixColumn = props.prefixColumn,
|
|
locale = props.locale,
|
|
rowCount = props.rowCount,
|
|
viewDate = props.viewDate,
|
|
value = props.value,
|
|
dateRender = props.dateRender;
|
|
var _React$useContext = react.useContext(es_RangeContext),
|
|
rangedValue = _React$useContext.rangedValue,
|
|
hoverRangedValue = _React$useContext.hoverRangedValue;
|
|
var baseDate = getWeekStartDate(locale.locale, generateConfig, viewDate);
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var weekFirstDay = generateConfig.locale.getWeekFirstDay(locale.locale);
|
|
var today = generateConfig.getNow();
|
|
// ============================== Header ==============================
|
|
var headerCells = [];
|
|
var weekDaysLocale = locale.shortWeekDays || (generateConfig.locale.getShortWeekDays ? generateConfig.locale.getShortWeekDays(locale.locale) : []);
|
|
if (prefixColumn) {
|
|
headerCells.push( /*#__PURE__*/react.createElement("th", {
|
|
key: "empty",
|
|
"aria-label": "empty cell"
|
|
}));
|
|
}
|
|
for (var i = 0; i < WEEK_DAY_COUNT; i += 1) {
|
|
headerCells.push( /*#__PURE__*/react.createElement("th", {
|
|
key: i
|
|
}, weekDaysLocale[(i + weekFirstDay) % WEEK_DAY_COUNT]));
|
|
}
|
|
// =============================== Body ===============================
|
|
var getCellClassName = useCellClassName({
|
|
cellPrefixCls: cellPrefixCls,
|
|
today: today,
|
|
value: value,
|
|
generateConfig: generateConfig,
|
|
rangedValue: prefixColumn ? null : rangedValue,
|
|
hoverRangedValue: prefixColumn ? null : hoverRangedValue,
|
|
isSameCell: function isSameCell(current, target) {
|
|
return isSameDate(generateConfig, current, target);
|
|
},
|
|
isInView: function isInView(date) {
|
|
return isSameMonth(generateConfig, date, viewDate);
|
|
},
|
|
offsetCell: function offsetCell(date, offset) {
|
|
return generateConfig.addDate(date, offset);
|
|
}
|
|
});
|
|
var getCellNode = dateRender ? function (date) {
|
|
return dateRender(date, today);
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: rowCount,
|
|
colNum: WEEK_DAY_COUNT,
|
|
baseDate: baseDate,
|
|
getCellNode: getCellNode,
|
|
getCellText: generateConfig.getDate,
|
|
getCellClassName: getCellClassName,
|
|
getCellDate: generateConfig.addDate,
|
|
titleCell: function titleCell(date) {
|
|
return formatValue(date, {
|
|
locale: locale,
|
|
format: 'YYYY-MM-DD',
|
|
generateConfig: generateConfig
|
|
});
|
|
},
|
|
headerCells: headerCells
|
|
}));
|
|
}
|
|
/* harmony default export */ var DatePanel_DateBody = (DateBody);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DatePanel/DateHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function DateHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
viewDate = props.viewDate,
|
|
onNextMonth = props.onNextMonth,
|
|
onPrevMonth = props.onPrevMonth,
|
|
onNextYear = props.onNextYear,
|
|
onPrevYear = props.onPrevYear,
|
|
onYearClick = props.onYearClick,
|
|
onMonthClick = props.onMonthClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
var monthsLocale = locale.shortMonths || (generateConfig.locale.getShortMonths ? generateConfig.locale.getShortMonths(locale.locale) : []);
|
|
var month = generateConfig.getMonth(viewDate);
|
|
// =================== Month & Year ===================
|
|
var yearNode = /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
key: "year",
|
|
onClick: onYearClick,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-year-btn")
|
|
}, formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.yearFormat,
|
|
generateConfig: generateConfig
|
|
}));
|
|
var monthNode = /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
key: "month",
|
|
onClick: onMonthClick,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-month-btn")
|
|
}, locale.monthFormat ? formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.monthFormat,
|
|
generateConfig: generateConfig
|
|
}) : monthsLocale[month]);
|
|
var monthYearNodes = locale.monthBeforeYear ? [monthNode, yearNode] : [yearNode, monthNode];
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevYear,
|
|
onPrev: onPrevMonth,
|
|
onNext: onNextMonth,
|
|
onSuperNext: onNextYear
|
|
}), monthYearNodes);
|
|
}
|
|
/* harmony default export */ var DatePanel_DateHeader = (DateHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DatePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var DATE_ROW_COUNT = 6;
|
|
function DatePanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
_props$panelName = props.panelName,
|
|
panelName = _props$panelName === void 0 ? 'date' : _props$panelName,
|
|
keyboardConfig = props.keyboardConfig,
|
|
active = props.active,
|
|
operationRef = props.operationRef,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
onViewDateChange = props.onViewDateChange,
|
|
onPanelChange = props.onPanelChange,
|
|
_onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-").concat(panelName, "-panel");
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, (0,objectSpread2/* default */.Z)({
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addDate(value || viewDate, diff), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addDate(value || viewDate, diff * WEEK_DAY_COUNT), 'key');
|
|
},
|
|
onPageUpDown: function onPageUpDown(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff), 'key');
|
|
}
|
|
}, keyboardConfig));
|
|
}
|
|
};
|
|
// ==================== View Operation ====================
|
|
var onYearChange = function onYearChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
var onMonthChange = function onMonthChange(diff) {
|
|
var newDate = generateConfig.addMonth(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(panelPrefixCls, (0,defineProperty/* default */.Z)({}, "".concat(panelPrefixCls, "-active"), active))
|
|
}, /*#__PURE__*/react.createElement(DatePanel_DateHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
value: value,
|
|
viewDate: viewDate
|
|
// View Operation
|
|
,
|
|
onPrevYear: function onPrevYear() {
|
|
onYearChange(-1);
|
|
},
|
|
onNextYear: function onNextYear() {
|
|
onYearChange(1);
|
|
},
|
|
onPrevMonth: function onPrevMonth() {
|
|
onMonthChange(-1);
|
|
},
|
|
onNextMonth: function onNextMonth() {
|
|
onMonthChange(1);
|
|
},
|
|
onMonthClick: function onMonthClick() {
|
|
onPanelChange('month', viewDate);
|
|
},
|
|
onYearClick: function onYearClick() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(DatePanel_DateBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
onSelect: function onSelect(date) {
|
|
return _onSelect(date, 'mouse');
|
|
},
|
|
prefixCls: prefixCls,
|
|
value: value,
|
|
viewDate: viewDate,
|
|
rowCount: DATE_ROW_COUNT
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_DatePanel = (DatePanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DatetimePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var ACTIVE_PANEL = tuple('date', 'time');
|
|
function DatetimePanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
defaultValue = props.defaultValue,
|
|
disabledTime = props.disabledTime,
|
|
showTime = props.showTime,
|
|
onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-datetime-panel");
|
|
var _React$useState = react.useState(null),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activePanel = _React$useState2[0],
|
|
setActivePanel = _React$useState2[1];
|
|
var dateOperationRef = react.useRef({});
|
|
var timeOperationRef = react.useRef({});
|
|
var timeProps = (0,esm_typeof/* default */.Z)(showTime) === 'object' ? (0,objectSpread2/* default */.Z)({}, showTime) : {};
|
|
// ======================= Keyboard =======================
|
|
function getNextActive(offset) {
|
|
var activeIndex = ACTIVE_PANEL.indexOf(activePanel) + offset;
|
|
var nextActivePanel = ACTIVE_PANEL[activeIndex] || null;
|
|
return nextActivePanel;
|
|
}
|
|
var onBlur = function onBlur(e) {
|
|
if (timeOperationRef.current.onBlur) {
|
|
timeOperationRef.current.onBlur(e);
|
|
}
|
|
setActivePanel(null);
|
|
};
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
// Switch active panel
|
|
if (event.which === KeyCode/* default.TAB */.Z.TAB) {
|
|
var nextActivePanel = getNextActive(event.shiftKey ? -1 : 1);
|
|
setActivePanel(nextActivePanel);
|
|
if (nextActivePanel) {
|
|
event.preventDefault();
|
|
}
|
|
return true;
|
|
}
|
|
// Operate on current active panel
|
|
if (activePanel) {
|
|
var ref = activePanel === 'date' ? dateOperationRef : timeOperationRef;
|
|
if (ref.current && ref.current.onKeyDown) {
|
|
ref.current.onKeyDown(event);
|
|
}
|
|
return true;
|
|
}
|
|
// Switch first active panel if operate without panel
|
|
if ([KeyCode/* default.LEFT */.Z.LEFT, KeyCode/* default.RIGHT */.Z.RIGHT, KeyCode/* default.UP */.Z.UP, KeyCode/* default.DOWN */.Z.DOWN].includes(event.which)) {
|
|
setActivePanel('date');
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
onBlur: onBlur,
|
|
onClose: onBlur
|
|
};
|
|
// ======================== Events ========================
|
|
var onInternalSelect = function onInternalSelect(date, source) {
|
|
var selectedDate = date;
|
|
if (source === 'date' && !value && timeProps.defaultValue) {
|
|
// Date with time defaultValue
|
|
selectedDate = generateConfig.setHour(selectedDate, generateConfig.getHour(timeProps.defaultValue));
|
|
selectedDate = generateConfig.setMinute(selectedDate, generateConfig.getMinute(timeProps.defaultValue));
|
|
selectedDate = generateConfig.setSecond(selectedDate, generateConfig.getSecond(timeProps.defaultValue));
|
|
} else if (source === 'time' && !value && defaultValue) {
|
|
selectedDate = generateConfig.setYear(selectedDate, generateConfig.getYear(defaultValue));
|
|
selectedDate = generateConfig.setMonth(selectedDate, generateConfig.getMonth(defaultValue));
|
|
selectedDate = generateConfig.setDate(selectedDate, generateConfig.getDate(defaultValue));
|
|
}
|
|
if (onSelect) {
|
|
onSelect(selectedDate, 'mouse');
|
|
}
|
|
};
|
|
// ======================== Render ========================
|
|
var disabledTimes = disabledTime ? disabledTime(value || null) : {};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(panelPrefixCls, (0,defineProperty/* default */.Z)({}, "".concat(panelPrefixCls, "-active"), activePanel))
|
|
}, /*#__PURE__*/react.createElement(panels_DatePanel, (0,esm_extends/* default */.Z)({}, props, {
|
|
operationRef: dateOperationRef,
|
|
active: activePanel === 'date',
|
|
onSelect: function onSelect(date) {
|
|
onInternalSelect(setDateTime(generateConfig, date, !value && (0,esm_typeof/* default */.Z)(showTime) === 'object' ? showTime.defaultValue : null), 'date');
|
|
}
|
|
})), /*#__PURE__*/react.createElement(panels_TimePanel, (0,esm_extends/* default */.Z)({}, props, {
|
|
format: undefined
|
|
}, timeProps, disabledTimes, {
|
|
disabledTime: null,
|
|
defaultValue: undefined,
|
|
operationRef: timeOperationRef,
|
|
active: activePanel === 'time',
|
|
onSelect: function onSelect(date) {
|
|
onInternalSelect(date, 'time');
|
|
}
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_DatetimePanel = (DatetimePanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/WeekPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function WeekPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
value = props.value;
|
|
// Render additional column
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var prefixColumn = function prefixColumn(date) {
|
|
return /*#__PURE__*/react.createElement("td", {
|
|
key: "week",
|
|
className: classnames_default()(cellPrefixCls, "".concat(cellPrefixCls, "-week"))
|
|
}, generateConfig.locale.getWeek(locale.locale, date));
|
|
};
|
|
// Add row className
|
|
var rowPrefixCls = "".concat(prefixCls, "-week-panel-row");
|
|
var rowClassName = function rowClassName(date) {
|
|
return classnames_default()(rowPrefixCls, (0,defineProperty/* default */.Z)({}, "".concat(rowPrefixCls, "-selected"), isSameWeek(generateConfig, locale.locale, value, date)));
|
|
};
|
|
return /*#__PURE__*/react.createElement(panels_DatePanel, (0,esm_extends/* default */.Z)({}, props, {
|
|
panelName: "week",
|
|
prefixColumn: prefixColumn,
|
|
rowClassName: rowClassName,
|
|
keyboardConfig: {
|
|
onLeftRight: null
|
|
}
|
|
}));
|
|
}
|
|
/* harmony default export */ var panels_WeekPanel = (WeekPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/MonthPanel/MonthHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function MonthHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
viewDate = props.viewDate,
|
|
onNextYear = props.onNextYear,
|
|
onPrevYear = props.onPrevYear,
|
|
onYearClick = props.onYearClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevYear,
|
|
onSuperNext: onNextYear
|
|
}), /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onYearClick,
|
|
className: "".concat(prefixCls, "-year-btn")
|
|
}, formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.yearFormat,
|
|
generateConfig: generateConfig
|
|
})));
|
|
}
|
|
/* harmony default export */ var MonthPanel_MonthHeader = (MonthHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/MonthPanel/MonthBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var MONTH_COL_COUNT = 3;
|
|
var MONTH_ROW_COUNT = 4;
|
|
function MonthBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
locale = props.locale,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
generateConfig = props.generateConfig,
|
|
monthCellRender = props.monthCellRender;
|
|
var _React$useContext = react.useContext(es_RangeContext),
|
|
rangedValue = _React$useContext.rangedValue,
|
|
hoverRangedValue = _React$useContext.hoverRangedValue;
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var getCellClassName = useCellClassName({
|
|
cellPrefixCls: cellPrefixCls,
|
|
value: value,
|
|
generateConfig: generateConfig,
|
|
rangedValue: rangedValue,
|
|
hoverRangedValue: hoverRangedValue,
|
|
isSameCell: function isSameCell(current, target) {
|
|
return isSameMonth(generateConfig, current, target);
|
|
},
|
|
isInView: function isInView() {
|
|
return true;
|
|
},
|
|
offsetCell: function offsetCell(date, offset) {
|
|
return generateConfig.addMonth(date, offset);
|
|
}
|
|
});
|
|
var monthsLocale = locale.shortMonths || (generateConfig.locale.getShortMonths ? generateConfig.locale.getShortMonths(locale.locale) : []);
|
|
var baseMonth = generateConfig.setMonth(viewDate, 0);
|
|
var getCellNode = monthCellRender ? function (date) {
|
|
return monthCellRender(date, locale);
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: MONTH_ROW_COUNT,
|
|
colNum: MONTH_COL_COUNT,
|
|
baseDate: baseMonth,
|
|
getCellNode: getCellNode,
|
|
getCellText: function getCellText(date) {
|
|
return locale.monthFormat ? formatValue(date, {
|
|
locale: locale,
|
|
format: locale.monthFormat,
|
|
generateConfig: generateConfig
|
|
}) : monthsLocale[generateConfig.getMonth(date)];
|
|
},
|
|
getCellClassName: getCellClassName,
|
|
getCellDate: generateConfig.addMonth,
|
|
titleCell: function titleCell(date) {
|
|
return formatValue(date, {
|
|
locale: locale,
|
|
format: 'YYYY-MM',
|
|
generateConfig: generateConfig
|
|
});
|
|
}
|
|
}));
|
|
}
|
|
/* harmony default export */ var MonthPanel_MonthBody = (MonthBody);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/MonthPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
function MonthPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
onViewDateChange = props.onViewDateChange,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
onPanelChange = props.onPanelChange,
|
|
_onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-month-panel");
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff * MONTH_COL_COUNT), 'key');
|
|
},
|
|
onEnter: function onEnter() {
|
|
onPanelChange('date', value || viewDate);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
// ==================== View Operation ====================
|
|
var onYearChange = function onYearChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: panelPrefixCls
|
|
}, /*#__PURE__*/react.createElement(MonthPanel_MonthHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onPrevYear: function onPrevYear() {
|
|
onYearChange(-1);
|
|
},
|
|
onNextYear: function onNextYear() {
|
|
onYearChange(1);
|
|
},
|
|
onYearClick: function onYearClick() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(MonthPanel_MonthBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onSelect: function onSelect(date) {
|
|
_onSelect(date, 'mouse');
|
|
onPanelChange('date', date);
|
|
}
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_MonthPanel = (MonthPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/QuarterPanel/QuarterHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function QuarterHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
viewDate = props.viewDate,
|
|
onNextYear = props.onNextYear,
|
|
onPrevYear = props.onPrevYear,
|
|
onYearClick = props.onYearClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevYear,
|
|
onSuperNext: onNextYear
|
|
}), /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onYearClick,
|
|
className: "".concat(prefixCls, "-year-btn")
|
|
}, formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.yearFormat,
|
|
generateConfig: generateConfig
|
|
})));
|
|
}
|
|
/* harmony default export */ var QuarterPanel_QuarterHeader = (QuarterHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/QuarterPanel/QuarterBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var QUARTER_COL_COUNT = 4;
|
|
var QUARTER_ROW_COUNT = 1;
|
|
function QuarterBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
locale = props.locale,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
generateConfig = props.generateConfig;
|
|
var _React$useContext = react.useContext(es_RangeContext),
|
|
rangedValue = _React$useContext.rangedValue,
|
|
hoverRangedValue = _React$useContext.hoverRangedValue;
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var getCellClassName = useCellClassName({
|
|
cellPrefixCls: cellPrefixCls,
|
|
value: value,
|
|
generateConfig: generateConfig,
|
|
rangedValue: rangedValue,
|
|
hoverRangedValue: hoverRangedValue,
|
|
isSameCell: function isSameCell(current, target) {
|
|
return isSameQuarter(generateConfig, current, target);
|
|
},
|
|
isInView: function isInView() {
|
|
return true;
|
|
},
|
|
offsetCell: function offsetCell(date, offset) {
|
|
return generateConfig.addMonth(date, offset * 3);
|
|
}
|
|
});
|
|
var baseQuarter = generateConfig.setDate(generateConfig.setMonth(viewDate, 0), 1);
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: QUARTER_ROW_COUNT,
|
|
colNum: QUARTER_COL_COUNT,
|
|
baseDate: baseQuarter,
|
|
getCellText: function getCellText(date) {
|
|
return formatValue(date, {
|
|
locale: locale,
|
|
format: locale.quarterFormat || '[Q]Q',
|
|
generateConfig: generateConfig
|
|
});
|
|
},
|
|
getCellClassName: getCellClassName,
|
|
getCellDate: function getCellDate(date, offset) {
|
|
return generateConfig.addMonth(date, offset * 3);
|
|
},
|
|
titleCell: function titleCell(date) {
|
|
return formatValue(date, {
|
|
locale: locale,
|
|
format: 'YYYY-[Q]Q',
|
|
generateConfig: generateConfig
|
|
});
|
|
}
|
|
}));
|
|
}
|
|
/* harmony default export */ var QuarterPanel_QuarterBody = (QuarterBody);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/QuarterPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
function QuarterPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
onViewDateChange = props.onViewDateChange,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
onPanelChange = props.onPanelChange,
|
|
_onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-quarter-panel");
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff * 3), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
}
|
|
});
|
|
}
|
|
};
|
|
// ==================== View Operation ====================
|
|
var onYearChange = function onYearChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: panelPrefixCls
|
|
}, /*#__PURE__*/react.createElement(QuarterPanel_QuarterHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onPrevYear: function onPrevYear() {
|
|
onYearChange(-1);
|
|
},
|
|
onNextYear: function onNextYear() {
|
|
onYearChange(1);
|
|
},
|
|
onYearClick: function onYearClick() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(QuarterPanel_QuarterBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onSelect: function onSelect(date) {
|
|
_onSelect(date, 'mouse');
|
|
}
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_QuarterPanel = (QuarterPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/YearPanel/YearHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function YearHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
viewDate = props.viewDate,
|
|
onPrevDecade = props.onPrevDecade,
|
|
onNextDecade = props.onNextDecade,
|
|
onDecadeClick = props.onDecadeClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
var yearNumber = generateConfig.getYear(viewDate);
|
|
var startYear = Math.floor(yearNumber / YEAR_DECADE_COUNT) * YEAR_DECADE_COUNT;
|
|
var endYear = startYear + YEAR_DECADE_COUNT - 1;
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevDecade,
|
|
onSuperNext: onNextDecade
|
|
}), /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onDecadeClick,
|
|
className: "".concat(prefixCls, "-decade-btn")
|
|
}, startYear, "-", endYear));
|
|
}
|
|
/* harmony default export */ var YearPanel_YearHeader = (YearHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/YearPanel/YearBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var YEAR_COL_COUNT = 3;
|
|
var YEAR_ROW_COUNT = 4;
|
|
function YearBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
locale = props.locale,
|
|
generateConfig = props.generateConfig;
|
|
var _React$useContext = react.useContext(es_RangeContext),
|
|
rangedValue = _React$useContext.rangedValue,
|
|
hoverRangedValue = _React$useContext.hoverRangedValue;
|
|
var yearPrefixCls = "".concat(prefixCls, "-cell");
|
|
// =============================== Year ===============================
|
|
var yearNumber = generateConfig.getYear(viewDate);
|
|
var startYear = Math.floor(yearNumber / YEAR_DECADE_COUNT) * YEAR_DECADE_COUNT;
|
|
var endYear = startYear + YEAR_DECADE_COUNT - 1;
|
|
var baseYear = generateConfig.setYear(viewDate, startYear - Math.ceil((YEAR_COL_COUNT * YEAR_ROW_COUNT - YEAR_DECADE_COUNT) / 2));
|
|
var isInView = function isInView(date) {
|
|
var currentYearNumber = generateConfig.getYear(date);
|
|
return startYear <= currentYearNumber && currentYearNumber <= endYear;
|
|
};
|
|
var getCellClassName = useCellClassName({
|
|
cellPrefixCls: yearPrefixCls,
|
|
value: value,
|
|
generateConfig: generateConfig,
|
|
rangedValue: rangedValue,
|
|
hoverRangedValue: hoverRangedValue,
|
|
isSameCell: function isSameCell(current, target) {
|
|
return isSameYear(generateConfig, current, target);
|
|
},
|
|
isInView: isInView,
|
|
offsetCell: function offsetCell(date, offset) {
|
|
return generateConfig.addYear(date, offset);
|
|
}
|
|
});
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: YEAR_ROW_COUNT,
|
|
colNum: YEAR_COL_COUNT,
|
|
baseDate: baseYear,
|
|
getCellText: generateConfig.getYear,
|
|
getCellClassName: getCellClassName,
|
|
getCellDate: generateConfig.addYear,
|
|
titleCell: function titleCell(date) {
|
|
return formatValue(date, {
|
|
locale: locale,
|
|
format: 'YYYY',
|
|
generateConfig: generateConfig
|
|
});
|
|
}
|
|
}));
|
|
}
|
|
/* harmony default export */ var YearPanel_YearBody = (YearBody);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/YearPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
var YEAR_DECADE_COUNT = 10;
|
|
function YearPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
onViewDateChange = props.onViewDateChange,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
sourceMode = props.sourceMode,
|
|
_onSelect = props.onSelect,
|
|
onPanelChange = props.onPanelChange;
|
|
var panelPrefixCls = "".concat(prefixCls, "-year-panel");
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff * YEAR_DECADE_COUNT), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff * YEAR_COL_COUNT), 'key');
|
|
},
|
|
onEnter: function onEnter() {
|
|
onPanelChange(sourceMode === 'date' ? 'date' : 'month', value || viewDate);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
// ==================== View Operation ====================
|
|
var onDecadeChange = function onDecadeChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff * 10);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: panelPrefixCls
|
|
}, /*#__PURE__*/react.createElement(YearPanel_YearHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onPrevDecade: function onPrevDecade() {
|
|
onDecadeChange(-1);
|
|
},
|
|
onNextDecade: function onNextDecade() {
|
|
onDecadeChange(1);
|
|
},
|
|
onDecadeClick: function onDecadeClick() {
|
|
onPanelChange('decade', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(YearPanel_YearBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onSelect: function onSelect(date) {
|
|
onPanelChange(sourceMode === 'date' ? 'date' : 'month', date);
|
|
_onSelect(date, 'mouse');
|
|
}
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_YearPanel = (YearPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/getExtraFooter.js
|
|
|
|
function getExtraFooter(prefixCls, mode, renderExtraFooter) {
|
|
if (!renderExtraFooter) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-footer-extra")
|
|
}, renderExtraFooter(mode));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/getRanges.js
|
|
|
|
function getRanges(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
_ref$rangeList = _ref.rangeList,
|
|
rangeList = _ref$rangeList === void 0 ? [] : _ref$rangeList,
|
|
_ref$components = _ref.components,
|
|
components = _ref$components === void 0 ? {} : _ref$components,
|
|
needConfirmButton = _ref.needConfirmButton,
|
|
onNow = _ref.onNow,
|
|
onOk = _ref.onOk,
|
|
okDisabled = _ref.okDisabled,
|
|
showNow = _ref.showNow,
|
|
locale = _ref.locale;
|
|
var presetNode;
|
|
var okNode;
|
|
if (rangeList.length) {
|
|
var Item = components.rangeItem || 'span';
|
|
presetNode = /*#__PURE__*/react.createElement(react.Fragment, null, rangeList.map(function (_ref2) {
|
|
var label = _ref2.label,
|
|
onClick = _ref2.onClick,
|
|
onMouseEnter = _ref2.onMouseEnter,
|
|
onMouseLeave = _ref2.onMouseLeave;
|
|
return /*#__PURE__*/react.createElement("li", {
|
|
key: label,
|
|
className: "".concat(prefixCls, "-preset")
|
|
}, /*#__PURE__*/react.createElement(Item, {
|
|
onClick: onClick,
|
|
onMouseEnter: onMouseEnter,
|
|
onMouseLeave: onMouseLeave
|
|
}, label));
|
|
}));
|
|
}
|
|
if (needConfirmButton) {
|
|
var Button = components.button || 'button';
|
|
if (onNow && !presetNode && showNow !== false) {
|
|
presetNode = /*#__PURE__*/react.createElement("li", {
|
|
className: "".concat(prefixCls, "-now")
|
|
}, /*#__PURE__*/react.createElement("a", {
|
|
className: "".concat(prefixCls, "-now-btn"),
|
|
onClick: onNow
|
|
}, locale.now));
|
|
}
|
|
okNode = needConfirmButton && /*#__PURE__*/react.createElement("li", {
|
|
className: "".concat(prefixCls, "-ok")
|
|
}, /*#__PURE__*/react.createElement(Button, {
|
|
disabled: okDisabled,
|
|
onClick: onOk
|
|
}, locale.ok));
|
|
}
|
|
if (!presetNode && !okNode) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement("ul", {
|
|
className: "".concat(prefixCls, "-ranges")
|
|
}, presetNode, okNode);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/PickerPanel.js
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Logic:
|
|
* When `mode` === `picker`,
|
|
* click will trigger `onSelect` (if value changed trigger `onChange` also).
|
|
* Panel change will not trigger `onSelect` but trigger `onPanelChange`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function PickerPanel(props) {
|
|
var _classNames;
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
|
|
className = props.className,
|
|
style = props.style,
|
|
locale = props.locale,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
defaultValue = props.defaultValue,
|
|
pickerValue = props.pickerValue,
|
|
defaultPickerValue = props.defaultPickerValue,
|
|
disabledDate = props.disabledDate,
|
|
mode = props.mode,
|
|
_props$picker = props.picker,
|
|
picker = _props$picker === void 0 ? 'date' : _props$picker,
|
|
_props$tabIndex = props.tabIndex,
|
|
tabIndex = _props$tabIndex === void 0 ? 0 : _props$tabIndex,
|
|
showNow = props.showNow,
|
|
showTime = props.showTime,
|
|
showToday = props.showToday,
|
|
renderExtraFooter = props.renderExtraFooter,
|
|
hideHeader = props.hideHeader,
|
|
onSelect = props.onSelect,
|
|
onChange = props.onChange,
|
|
onPanelChange = props.onPanelChange,
|
|
onMouseDown = props.onMouseDown,
|
|
onPickerValueChange = props.onPickerValueChange,
|
|
_onOk = props.onOk,
|
|
components = props.components,
|
|
direction = props.direction,
|
|
_props$hourStep = props.hourStep,
|
|
hourStep = _props$hourStep === void 0 ? 1 : _props$hourStep,
|
|
_props$minuteStep = props.minuteStep,
|
|
minuteStep = _props$minuteStep === void 0 ? 1 : _props$minuteStep,
|
|
_props$secondStep = props.secondStep,
|
|
secondStep = _props$secondStep === void 0 ? 1 : _props$secondStep;
|
|
var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
|
|
var isHourStepValid = 24 % hourStep === 0;
|
|
var isMinuteStepValid = 60 % minuteStep === 0;
|
|
var isSecondStepValid = 60 % secondStep === 0;
|
|
if (false) {}
|
|
// ============================ State =============================
|
|
var panelContext = react.useContext(es_PanelContext);
|
|
var operationRef = panelContext.operationRef,
|
|
panelDivRef = panelContext.panelRef,
|
|
onContextSelect = panelContext.onSelect,
|
|
hideRanges = panelContext.hideRanges,
|
|
defaultOpenValue = panelContext.defaultOpenValue;
|
|
var _React$useContext = react.useContext(es_RangeContext),
|
|
inRange = _React$useContext.inRange,
|
|
panelPosition = _React$useContext.panelPosition,
|
|
rangedValue = _React$useContext.rangedValue,
|
|
hoverRangedValue = _React$useContext.hoverRangedValue;
|
|
var panelRef = react.useRef({});
|
|
// Handle init logic
|
|
var initRef = react.useRef(true);
|
|
// Value
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(null, {
|
|
value: value,
|
|
defaultValue: defaultValue,
|
|
postState: function postState(val) {
|
|
if (!val && defaultOpenValue && picker === 'time') {
|
|
return defaultOpenValue;
|
|
}
|
|
return val;
|
|
}
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
mergedValue = _useMergedState2[0],
|
|
setInnerValue = _useMergedState2[1];
|
|
// View date control
|
|
var _useMergedState3 = (0,useMergedState/* default */.Z)(null, {
|
|
value: pickerValue,
|
|
defaultValue: defaultPickerValue || mergedValue,
|
|
postState: function postState(date) {
|
|
var now = generateConfig.getNow();
|
|
if (!date) {
|
|
return now;
|
|
}
|
|
// When value is null and set showTime
|
|
if (!mergedValue && showTime) {
|
|
var defaultDateObject = (0,esm_typeof/* default */.Z)(showTime) === 'object' ? showTime.defaultValue : defaultValue;
|
|
return setDateTime(generateConfig, Array.isArray(date) ? date[0] : date, defaultDateObject || now);
|
|
}
|
|
return Array.isArray(date) ? date[0] : date;
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
viewDate = _useMergedState4[0],
|
|
setInnerViewDate = _useMergedState4[1];
|
|
var setViewDate = function setViewDate(date) {
|
|
setInnerViewDate(date);
|
|
if (onPickerValueChange) {
|
|
onPickerValueChange(date);
|
|
}
|
|
};
|
|
// Panel control
|
|
var getInternalNextMode = function getInternalNextMode(nextMode) {
|
|
var getNextMode = PickerModeMap[picker];
|
|
if (getNextMode) {
|
|
return getNextMode(nextMode);
|
|
}
|
|
return nextMode;
|
|
};
|
|
// Save panel is changed from which panel
|
|
var _useMergedState5 = (0,useMergedState/* default */.Z)(function () {
|
|
if (picker === 'time') {
|
|
return 'time';
|
|
}
|
|
return getInternalNextMode('date');
|
|
}, {
|
|
value: mode
|
|
}),
|
|
_useMergedState6 = (0,slicedToArray/* default */.Z)(_useMergedState5, 2),
|
|
mergedMode = _useMergedState6[0],
|
|
setInnerMode = _useMergedState6[1];
|
|
react.useEffect(function () {
|
|
setInnerMode(picker);
|
|
}, [picker]);
|
|
var _React$useState = react.useState(function () {
|
|
return mergedMode;
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
sourceMode = _React$useState2[0],
|
|
setSourceMode = _React$useState2[1];
|
|
var onInternalPanelChange = function onInternalPanelChange(newMode, viewValue) {
|
|
var nextMode = getInternalNextMode(newMode || mergedMode);
|
|
setSourceMode(mergedMode);
|
|
setInnerMode(nextMode);
|
|
if (onPanelChange && (mergedMode !== nextMode || isEqual(generateConfig, viewDate, viewDate))) {
|
|
onPanelChange(viewValue, nextMode);
|
|
}
|
|
};
|
|
var triggerSelect = function triggerSelect(date, type) {
|
|
var forceTriggerSelect = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
if (mergedMode === picker || forceTriggerSelect) {
|
|
setInnerValue(date);
|
|
if (onSelect) {
|
|
onSelect(date);
|
|
}
|
|
if (onContextSelect) {
|
|
onContextSelect(date, type);
|
|
}
|
|
if (onChange && !isEqual(generateConfig, date, mergedValue) && !(disabledDate === null || disabledDate === void 0 ? void 0 : disabledDate(date))) {
|
|
onChange(date);
|
|
}
|
|
}
|
|
};
|
|
// ========================= Interactive ==========================
|
|
var onInternalKeyDown = function onInternalKeyDown(e) {
|
|
if (panelRef.current && panelRef.current.onKeyDown) {
|
|
if ([KeyCode/* default.LEFT */.Z.LEFT, KeyCode/* default.RIGHT */.Z.RIGHT, KeyCode/* default.UP */.Z.UP, KeyCode/* default.DOWN */.Z.DOWN, KeyCode/* default.PAGE_UP */.Z.PAGE_UP, KeyCode/* default.PAGE_DOWN */.Z.PAGE_DOWN, KeyCode/* default.ENTER */.Z.ENTER].includes(e.which)) {
|
|
e.preventDefault();
|
|
}
|
|
return panelRef.current.onKeyDown(e);
|
|
}
|
|
/* istanbul ignore next */
|
|
/* eslint-disable no-lone-blocks */
|
|
{
|
|
(0,es_warning/* default */.ZP)(false, 'Panel not correct handle keyDown event. Please help to fire issue about this.');
|
|
return false;
|
|
}
|
|
/* eslint-enable no-lone-blocks */
|
|
};
|
|
|
|
var onInternalBlur = function onInternalBlur(e) {
|
|
if (panelRef.current && panelRef.current.onBlur) {
|
|
panelRef.current.onBlur(e);
|
|
}
|
|
};
|
|
if (operationRef && panelPosition !== 'right') {
|
|
operationRef.current = {
|
|
onKeyDown: onInternalKeyDown,
|
|
onClose: function onClose() {
|
|
if (panelRef.current && panelRef.current.onClose) {
|
|
panelRef.current.onClose();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
// ============================ Effect ============================
|
|
react.useEffect(function () {
|
|
if (value && !initRef.current) {
|
|
setInnerViewDate(value);
|
|
}
|
|
}, [value]);
|
|
react.useEffect(function () {
|
|
initRef.current = false;
|
|
}, []);
|
|
// ============================ Panels ============================
|
|
var panelNode;
|
|
var pickerProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
operationRef: panelRef,
|
|
prefixCls: prefixCls,
|
|
viewDate: viewDate,
|
|
value: mergedValue,
|
|
onViewDateChange: setViewDate,
|
|
sourceMode: sourceMode,
|
|
onPanelChange: onInternalPanelChange,
|
|
disabledDate: disabledDate
|
|
});
|
|
delete pickerProps.onChange;
|
|
delete pickerProps.onSelect;
|
|
switch (mergedMode) {
|
|
case 'decade':
|
|
panelNode = /*#__PURE__*/react.createElement(panels_DecadePanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
break;
|
|
case 'year':
|
|
panelNode = /*#__PURE__*/react.createElement(panels_YearPanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
break;
|
|
case 'month':
|
|
panelNode = /*#__PURE__*/react.createElement(panels_MonthPanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
break;
|
|
case 'quarter':
|
|
panelNode = /*#__PURE__*/react.createElement(panels_QuarterPanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
break;
|
|
case 'week':
|
|
panelNode = /*#__PURE__*/react.createElement(panels_WeekPanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
break;
|
|
case 'time':
|
|
delete pickerProps.showTime;
|
|
panelNode = /*#__PURE__*/react.createElement(panels_TimePanel, (0,esm_extends/* default */.Z)({}, pickerProps, (0,esm_typeof/* default */.Z)(showTime) === 'object' ? showTime : null, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
break;
|
|
default:
|
|
if (showTime) {
|
|
panelNode = /*#__PURE__*/react.createElement(panels_DatetimePanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
} else {
|
|
panelNode = /*#__PURE__*/react.createElement(panels_DatePanel, (0,esm_extends/* default */.Z)({}, pickerProps, {
|
|
onSelect: function onSelect(date, type) {
|
|
setViewDate(date);
|
|
triggerSelect(date, type);
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
// ============================ Footer ============================
|
|
var extraFooter;
|
|
var rangesNode;
|
|
var onNow = function onNow() {
|
|
var now = generateConfig.getNow();
|
|
var lowerBoundTime = getLowerBoundTime(generateConfig.getHour(now), generateConfig.getMinute(now), generateConfig.getSecond(now), isHourStepValid ? hourStep : 1, isMinuteStepValid ? minuteStep : 1, isSecondStepValid ? secondStep : 1);
|
|
var adjustedNow = timeUtil_setTime(generateConfig, now, lowerBoundTime[0],
|
|
// hour
|
|
lowerBoundTime[1],
|
|
// minute
|
|
lowerBoundTime[2]);
|
|
triggerSelect(adjustedNow, 'submit');
|
|
};
|
|
if (!hideRanges) {
|
|
extraFooter = getExtraFooter(prefixCls, mergedMode, renderExtraFooter);
|
|
rangesNode = getRanges({
|
|
prefixCls: prefixCls,
|
|
components: components,
|
|
needConfirmButton: needConfirmButton,
|
|
okDisabled: !mergedValue || disabledDate && disabledDate(mergedValue),
|
|
locale: locale,
|
|
showNow: showNow,
|
|
onNow: needConfirmButton && onNow,
|
|
onOk: function onOk() {
|
|
if (mergedValue) {
|
|
triggerSelect(mergedValue, 'submit', true);
|
|
if (_onOk) {
|
|
_onOk(mergedValue);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
var todayNode;
|
|
if (showToday && mergedMode === 'date' && picker === 'date' && !showTime) {
|
|
var now = generateConfig.getNow();
|
|
var todayCls = "".concat(prefixCls, "-today-btn");
|
|
var disabled = disabledDate && disabledDate(now);
|
|
todayNode = /*#__PURE__*/react.createElement("a", {
|
|
className: classnames_default()(todayCls, disabled && "".concat(todayCls, "-disabled")),
|
|
"aria-disabled": disabled,
|
|
onClick: function onClick() {
|
|
if (!disabled) {
|
|
triggerSelect(now, 'mouse', true);
|
|
}
|
|
}
|
|
}, locale.today);
|
|
}
|
|
return /*#__PURE__*/react.createElement(es_PanelContext.Provider, {
|
|
value: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, panelContext), {}, {
|
|
mode: mergedMode,
|
|
hideHeader: 'hideHeader' in props ? hideHeader : panelContext.hideHeader,
|
|
hidePrevBtn: inRange && panelPosition === 'right',
|
|
hideNextBtn: inRange && panelPosition === 'left'
|
|
})
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
tabIndex: tabIndex,
|
|
className: classnames_default()("".concat(prefixCls, "-panel"), className, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-panel-has-range"), rangedValue && rangedValue[0] && rangedValue[1]), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-panel-has-range-hover"), hoverRangedValue && hoverRangedValue[0] && hoverRangedValue[1]), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-panel-rtl"), direction === 'rtl'), _classNames)),
|
|
style: style,
|
|
onKeyDown: onInternalKeyDown,
|
|
onBlur: onInternalBlur,
|
|
onMouseDown: onMouseDown,
|
|
ref: panelDivRef
|
|
}, panelNode, extraFooter || rangesNode || todayNode ? /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-footer")
|
|
}, extraFooter, rangesNode, todayNode) : null));
|
|
}
|
|
/* harmony default export */ var es_PickerPanel = (PickerPanel);
|
|
/* eslint-enable */
|
|
// EXTERNAL MODULE: ./node_modules/rc-trigger/es/index.js + 15 modules
|
|
var es = __webpack_require__(81263);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/PickerTrigger.js
|
|
|
|
|
|
|
|
|
|
var BUILT_IN_PLACEMENTS = {
|
|
bottomLeft: {
|
|
points: ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow: {
|
|
adjustX: 1,
|
|
adjustY: 1
|
|
}
|
|
},
|
|
bottomRight: {
|
|
points: ['tr', 'br'],
|
|
offset: [0, 4],
|
|
overflow: {
|
|
adjustX: 1,
|
|
adjustY: 1
|
|
}
|
|
},
|
|
topLeft: {
|
|
points: ['bl', 'tl'],
|
|
offset: [0, -4],
|
|
overflow: {
|
|
adjustX: 0,
|
|
adjustY: 1
|
|
}
|
|
},
|
|
topRight: {
|
|
points: ['br', 'tr'],
|
|
offset: [0, -4],
|
|
overflow: {
|
|
adjustX: 0,
|
|
adjustY: 1
|
|
}
|
|
}
|
|
};
|
|
function PickerTrigger(_ref) {
|
|
var _classNames;
|
|
var prefixCls = _ref.prefixCls,
|
|
popupElement = _ref.popupElement,
|
|
popupStyle = _ref.popupStyle,
|
|
visible = _ref.visible,
|
|
dropdownClassName = _ref.dropdownClassName,
|
|
dropdownAlign = _ref.dropdownAlign,
|
|
transitionName = _ref.transitionName,
|
|
getPopupContainer = _ref.getPopupContainer,
|
|
children = _ref.children,
|
|
range = _ref.range,
|
|
popupPlacement = _ref.popupPlacement,
|
|
direction = _ref.direction;
|
|
var dropdownPrefixCls = "".concat(prefixCls, "-dropdown");
|
|
var getPopupPlacement = function getPopupPlacement() {
|
|
if (popupPlacement !== undefined) {
|
|
return popupPlacement;
|
|
}
|
|
return direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
|
|
};
|
|
return /*#__PURE__*/react.createElement(es/* default */.Z, {
|
|
showAction: [],
|
|
hideAction: [],
|
|
popupPlacement: getPopupPlacement(),
|
|
builtinPlacements: BUILT_IN_PLACEMENTS,
|
|
prefixCls: dropdownPrefixCls,
|
|
popupTransitionName: transitionName,
|
|
popup: popupElement,
|
|
popupAlign: dropdownAlign,
|
|
popupVisible: visible,
|
|
popupClassName: classnames_default()(dropdownClassName, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(dropdownPrefixCls, "-range"), range), (0,defineProperty/* default */.Z)(_classNames, "".concat(dropdownPrefixCls, "-rtl"), direction === 'rtl'), _classNames)),
|
|
popupStyle: popupStyle,
|
|
getPopupContainer: getPopupContainer
|
|
}, children);
|
|
}
|
|
/* harmony default export */ var es_PickerTrigger = (PickerTrigger);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/usePickerInput.js
|
|
|
|
|
|
|
|
|
|
function usePickerInput(_ref) {
|
|
var open = _ref.open,
|
|
value = _ref.value,
|
|
isClickOutside = _ref.isClickOutside,
|
|
triggerOpen = _ref.triggerOpen,
|
|
forwardKeyDown = _ref.forwardKeyDown,
|
|
_onKeyDown = _ref.onKeyDown,
|
|
blurToCancel = _ref.blurToCancel,
|
|
onSubmit = _ref.onSubmit,
|
|
onCancel = _ref.onCancel,
|
|
_onFocus = _ref.onFocus,
|
|
_onBlur = _ref.onBlur,
|
|
currentFocusedKey = _ref.currentFocusedKey,
|
|
_ref$key = _ref.key,
|
|
key = _ref$key === void 0 ? 'start' : _ref$key;
|
|
var _useState = (0,react.useState)(false),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
typing = _useState2[0],
|
|
setTyping = _useState2[1];
|
|
var _useState3 = (0,react.useState)(false),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
focused = _useState4[0],
|
|
setFocused = _useState4[1];
|
|
var delayBlurTimer = (0,react.useRef)();
|
|
/**
|
|
* We will prevent blur to handle open event when user click outside,
|
|
* since this will repeat trigger `onOpenChange` event.
|
|
*/
|
|
var preventBlurRef = (0,react.useRef)(false);
|
|
var valueChangedRef = (0,react.useRef)(false);
|
|
var preventDefaultRef = (0,react.useRef)(false);
|
|
var inputProps = {
|
|
onMouseDown: function onMouseDown() {
|
|
setTyping(true);
|
|
triggerOpen(true);
|
|
},
|
|
onKeyDown: function onKeyDown(e) {
|
|
var preventDefault = function preventDefault() {
|
|
preventDefaultRef.current = true;
|
|
};
|
|
_onKeyDown(e, preventDefault);
|
|
if (preventDefaultRef.current) return;
|
|
switch (e.which) {
|
|
case KeyCode/* default.ENTER */.Z.ENTER:
|
|
{
|
|
if (!open) {
|
|
triggerOpen(true);
|
|
} else if (onSubmit() !== false) {
|
|
setTyping(true);
|
|
}
|
|
e.preventDefault();
|
|
return;
|
|
}
|
|
case KeyCode/* default.TAB */.Z.TAB:
|
|
{
|
|
if (typing && open && !e.shiftKey) {
|
|
setTyping(false);
|
|
e.preventDefault();
|
|
} else if (!typing && open) {
|
|
if (!forwardKeyDown(e) && e.shiftKey) {
|
|
setTyping(true);
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
case KeyCode/* default.ESC */.Z.ESC:
|
|
{
|
|
setTyping(true);
|
|
onCancel();
|
|
return;
|
|
}
|
|
}
|
|
if (!open && ![KeyCode/* default.SHIFT */.Z.SHIFT].includes(e.which)) {
|
|
triggerOpen(true);
|
|
} else if (!typing) {
|
|
// Let popup panel handle keyboard
|
|
forwardKeyDown(e);
|
|
}
|
|
},
|
|
onFocus: function onFocus(e) {
|
|
setTyping(true);
|
|
setFocused(true);
|
|
if (currentFocusedKey) {
|
|
currentFocusedKey.current = key;
|
|
}
|
|
clearTimeout(delayBlurTimer.current);
|
|
if (_onFocus) {
|
|
_onFocus(e);
|
|
}
|
|
},
|
|
onBlur: function onBlur(e) {
|
|
if (preventBlurRef.current || !isClickOutside(document.activeElement)) {
|
|
preventBlurRef.current = false;
|
|
return;
|
|
}
|
|
if (blurToCancel) {
|
|
setTimeout(function () {
|
|
var _document = document,
|
|
activeElement = _document.activeElement;
|
|
while (activeElement && activeElement.shadowRoot) {
|
|
activeElement = activeElement.shadowRoot.activeElement;
|
|
}
|
|
if (isClickOutside(activeElement)) {
|
|
onCancel();
|
|
}
|
|
}, 0);
|
|
} else if (open) {
|
|
triggerOpen(false);
|
|
if (valueChangedRef.current) {
|
|
onSubmit();
|
|
}
|
|
}
|
|
setFocused(false);
|
|
if (currentFocusedKey) {
|
|
currentFocusedKey.current = '';
|
|
// Delay to prevent 'range' focus transitions from firing resulting in incorrect out-of-focus events
|
|
delayBlurTimer.current = setTimeout(function () {
|
|
// Prevent the 'blur' event from firing when there is currently a focused input
|
|
if (currentFocusedKey.current) {
|
|
return;
|
|
}
|
|
_onBlur === null || _onBlur === void 0 ? void 0 : _onBlur(e);
|
|
}, 100);
|
|
} else {
|
|
_onBlur === null || _onBlur === void 0 ? void 0 : _onBlur(e);
|
|
}
|
|
}
|
|
};
|
|
// check if value changed
|
|
(0,react.useEffect)(function () {
|
|
valueChangedRef.current = false;
|
|
}, [open]);
|
|
(0,react.useEffect)(function () {
|
|
valueChangedRef.current = true;
|
|
}, [value]);
|
|
// Global click handler
|
|
(0,react.useEffect)(function () {
|
|
return addGlobalMouseDownEvent(function (e) {
|
|
var target = getTargetFromEvent(e);
|
|
if (open) {
|
|
var clickedOutside = isClickOutside(target);
|
|
if (!clickedOutside) {
|
|
preventBlurRef.current = true;
|
|
// Always set back in case `onBlur` prevented by user
|
|
requestAnimationFrame(function () {
|
|
preventBlurRef.current = false;
|
|
});
|
|
} else if (!focused || clickedOutside) {
|
|
triggerOpen(false);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
(0,react.useEffect)(function () {
|
|
return function () {
|
|
return clearTimeout(delayBlurTimer.current);
|
|
};
|
|
}, []);
|
|
return [inputProps, {
|
|
focused: focused,
|
|
typing: typing
|
|
}];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useTextValueMapping.js
|
|
|
|
|
|
function useTextValueMapping(_ref) {
|
|
var valueTexts = _ref.valueTexts,
|
|
onTextChange = _ref.onTextChange;
|
|
var _React$useState = react.useState(''),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
text = _React$useState2[0],
|
|
setInnerText = _React$useState2[1];
|
|
var valueTextsRef = react.useRef([]);
|
|
valueTextsRef.current = valueTexts;
|
|
function triggerTextChange(value) {
|
|
setInnerText(value);
|
|
onTextChange(value);
|
|
}
|
|
function resetText() {
|
|
setInnerText(valueTextsRef.current[0]);
|
|
}
|
|
react.useEffect(function () {
|
|
if (valueTexts.every(function (valText) {
|
|
return valText !== text;
|
|
})) {
|
|
resetText();
|
|
}
|
|
}, [valueTexts.join('||')]);
|
|
return [text, triggerTextChange, resetText];
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/shallowequal/index.js
|
|
var shallowequal = __webpack_require__(96774);
|
|
var shallowequal_default = /*#__PURE__*/__webpack_require__.n(shallowequal);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useValueTexts.js
|
|
|
|
|
|
|
|
function useValueTexts(value, _ref) {
|
|
var formatList = _ref.formatList,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale;
|
|
return (0,useMemo/* default */.Z)(function () {
|
|
if (!value) {
|
|
return [[''], ''];
|
|
}
|
|
// We will convert data format back to first format
|
|
var firstValueText = '';
|
|
var fullValueTexts = [];
|
|
for (var i = 0; i < formatList.length; i += 1) {
|
|
var format = formatList[i];
|
|
var formatStr = formatValue(value, {
|
|
generateConfig: generateConfig,
|
|
locale: locale,
|
|
format: format
|
|
});
|
|
fullValueTexts.push(formatStr);
|
|
if (i === 0) {
|
|
firstValueText = formatStr;
|
|
}
|
|
}
|
|
return [fullValueTexts, firstValueText];
|
|
}, [value, formatList], function (prev, next) {
|
|
return prev[0] !== next[0] || !shallowequal_default()(prev[1], next[1]);
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useHoverValue.js
|
|
|
|
|
|
|
|
function useHoverValue(valueText, _ref) {
|
|
var formatList = _ref.formatList,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale;
|
|
var _useState = (0,react.useState)(null),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
value = _useState2[0],
|
|
internalSetValue = _useState2[1];
|
|
var raf = (0,react.useRef)(null);
|
|
function setValue(val) {
|
|
var immediately = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
cancelAnimationFrame(raf.current);
|
|
if (immediately) {
|
|
internalSetValue(val);
|
|
return;
|
|
}
|
|
raf.current = requestAnimationFrame(function () {
|
|
internalSetValue(val);
|
|
});
|
|
}
|
|
var _useValueTexts = useValueTexts(value, {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
}),
|
|
_useValueTexts2 = (0,slicedToArray/* default */.Z)(_useValueTexts, 2),
|
|
firstText = _useValueTexts2[1];
|
|
function onEnter(date) {
|
|
setValue(date);
|
|
}
|
|
function onLeave() {
|
|
var immediately = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
setValue(null, immediately);
|
|
}
|
|
(0,react.useEffect)(function () {
|
|
onLeave(true);
|
|
}, [valueText]);
|
|
(0,react.useEffect)(function () {
|
|
return function () {
|
|
return cancelAnimationFrame(raf.current);
|
|
};
|
|
}, []);
|
|
return [firstText, onEnter, onLeave];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/warnUtil.js
|
|
|
|
function legacyPropsWarning(props) {
|
|
var picker = props.picker,
|
|
disabledHours = props.disabledHours,
|
|
disabledMinutes = props.disabledMinutes,
|
|
disabledSeconds = props.disabledSeconds;
|
|
if (picker === 'time' && (disabledHours || disabledMinutes || disabledSeconds)) {
|
|
warning(false, "'disabledHours', 'disabledMinutes', 'disabledSeconds' will be removed in the next major version, please use 'disabledTime' instead.");
|
|
}
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/Picker.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Removed:
|
|
* - getCalendarContainer: use `getPopupContainer` instead
|
|
* - onOk
|
|
*
|
|
* New Feature:
|
|
* - picker
|
|
* - allowEmpty
|
|
* - selectable
|
|
*
|
|
* Tips: Should add faq about `datetime` mode with `defaultValue`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function InnerPicker(props) {
|
|
var _classNames2;
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
|
|
id = props.id,
|
|
tabIndex = props.tabIndex,
|
|
style = props.style,
|
|
className = props.className,
|
|
dropdownClassName = props.dropdownClassName,
|
|
dropdownAlign = props.dropdownAlign,
|
|
popupStyle = props.popupStyle,
|
|
transitionName = props.transitionName,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
inputReadOnly = props.inputReadOnly,
|
|
allowClear = props.allowClear,
|
|
autoFocus = props.autoFocus,
|
|
showTime = props.showTime,
|
|
_props$picker = props.picker,
|
|
picker = _props$picker === void 0 ? 'date' : _props$picker,
|
|
format = props.format,
|
|
use12Hours = props.use12Hours,
|
|
value = props.value,
|
|
defaultValue = props.defaultValue,
|
|
open = props.open,
|
|
defaultOpen = props.defaultOpen,
|
|
defaultOpenValue = props.defaultOpenValue,
|
|
suffixIcon = props.suffixIcon,
|
|
clearIcon = props.clearIcon,
|
|
disabled = props.disabled,
|
|
disabledDate = props.disabledDate,
|
|
placeholder = props.placeholder,
|
|
getPopupContainer = props.getPopupContainer,
|
|
pickerRef = props.pickerRef,
|
|
panelRender = props.panelRender,
|
|
onChange = props.onChange,
|
|
onOpenChange = props.onOpenChange,
|
|
onFocus = props.onFocus,
|
|
onBlur = props.onBlur,
|
|
onMouseDown = props.onMouseDown,
|
|
onMouseUp = props.onMouseUp,
|
|
onMouseEnter = props.onMouseEnter,
|
|
onMouseLeave = props.onMouseLeave,
|
|
onContextMenu = props.onContextMenu,
|
|
onClick = props.onClick,
|
|
_onKeyDown = props.onKeyDown,
|
|
_onSelect = props.onSelect,
|
|
direction = props.direction,
|
|
_props$autoComplete = props.autoComplete,
|
|
autoComplete = _props$autoComplete === void 0 ? 'off' : _props$autoComplete,
|
|
inputRender = props.inputRender;
|
|
var inputRef = react.useRef(null);
|
|
var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
|
|
// ============================ Warning ============================
|
|
if (false) {}
|
|
// ============================= State =============================
|
|
var formatList = toArray(getDefaultFormat(format, picker, showTime, use12Hours));
|
|
// Panel ref
|
|
var panelDivRef = react.useRef(null);
|
|
var inputDivRef = react.useRef(null);
|
|
var containerRef = react.useRef(null);
|
|
// Real value
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(null, {
|
|
value: value,
|
|
defaultValue: defaultValue
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
mergedValue = _useMergedState2[0],
|
|
setInnerValue = _useMergedState2[1];
|
|
// Selected value
|
|
var _React$useState = react.useState(mergedValue),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
selectedValue = _React$useState2[0],
|
|
setSelectedValue = _React$useState2[1];
|
|
// Operation ref
|
|
var operationRef = react.useRef(null);
|
|
// Open
|
|
var _useMergedState3 = (0,useMergedState/* default */.Z)(false, {
|
|
value: open,
|
|
defaultValue: defaultOpen,
|
|
postState: function postState(postOpen) {
|
|
return disabled ? false : postOpen;
|
|
},
|
|
onChange: function onChange(newOpen) {
|
|
if (onOpenChange) {
|
|
onOpenChange(newOpen);
|
|
}
|
|
if (!newOpen && operationRef.current && operationRef.current.onClose) {
|
|
operationRef.current.onClose();
|
|
}
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
mergedOpen = _useMergedState4[0],
|
|
triggerInnerOpen = _useMergedState4[1];
|
|
// ============================= Text ==============================
|
|
var _useValueTexts = useValueTexts(selectedValue, {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
}),
|
|
_useValueTexts2 = (0,slicedToArray/* default */.Z)(_useValueTexts, 2),
|
|
valueTexts = _useValueTexts2[0],
|
|
firstValueText = _useValueTexts2[1];
|
|
var _useTextValueMapping = useTextValueMapping({
|
|
valueTexts: valueTexts,
|
|
onTextChange: function onTextChange(newText) {
|
|
var inputDate = parseValue(newText, {
|
|
locale: locale,
|
|
formatList: formatList,
|
|
generateConfig: generateConfig
|
|
});
|
|
if (inputDate && (!disabledDate || !disabledDate(inputDate))) {
|
|
setSelectedValue(inputDate);
|
|
}
|
|
}
|
|
}),
|
|
_useTextValueMapping2 = (0,slicedToArray/* default */.Z)(_useTextValueMapping, 3),
|
|
text = _useTextValueMapping2[0],
|
|
triggerTextChange = _useTextValueMapping2[1],
|
|
resetText = _useTextValueMapping2[2];
|
|
// ============================ Trigger ============================
|
|
var triggerChange = function triggerChange(newValue) {
|
|
setSelectedValue(newValue);
|
|
setInnerValue(newValue);
|
|
if (onChange && !isEqual(generateConfig, mergedValue, newValue)) {
|
|
onChange(newValue, newValue ? formatValue(newValue, {
|
|
generateConfig: generateConfig,
|
|
locale: locale,
|
|
format: formatList[0]
|
|
}) : '');
|
|
}
|
|
};
|
|
var triggerOpen = function triggerOpen(newOpen) {
|
|
if (disabled && newOpen) {
|
|
return;
|
|
}
|
|
triggerInnerOpen(newOpen);
|
|
};
|
|
var forwardKeyDown = function forwardKeyDown(e) {
|
|
if (mergedOpen && operationRef.current && operationRef.current.onKeyDown) {
|
|
// Let popup panel handle keyboard
|
|
return operationRef.current.onKeyDown(e);
|
|
}
|
|
/* istanbul ignore next */
|
|
/* eslint-disable no-lone-blocks */
|
|
{
|
|
(0,es_warning/* default */.ZP)(false, 'Picker not correct forward KeyDown operation. Please help to fire issue about this.');
|
|
return false;
|
|
}
|
|
};
|
|
var onInternalClick = function onInternalClick() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
onClick === null || onClick === void 0 ? void 0 : onClick.apply(void 0, args);
|
|
if (inputRef.current) {
|
|
inputRef.current.focus();
|
|
triggerOpen(true);
|
|
}
|
|
};
|
|
// ============================= Input =============================
|
|
var _usePickerInput = usePickerInput({
|
|
blurToCancel: needConfirmButton,
|
|
open: mergedOpen,
|
|
value: text,
|
|
triggerOpen: triggerOpen,
|
|
forwardKeyDown: forwardKeyDown,
|
|
isClickOutside: function isClickOutside(target) {
|
|
return !elementsContains([panelDivRef.current, inputDivRef.current, containerRef.current], target);
|
|
},
|
|
onSubmit: function onSubmit() {
|
|
if (
|
|
// When user typing disabledDate with keyboard and enter, this value will be empty
|
|
!selectedValue ||
|
|
// Normal disabled check
|
|
disabledDate && disabledDate(selectedValue)) {
|
|
return false;
|
|
}
|
|
triggerChange(selectedValue);
|
|
triggerOpen(false);
|
|
resetText();
|
|
return true;
|
|
},
|
|
onCancel: function onCancel() {
|
|
triggerOpen(false);
|
|
setSelectedValue(mergedValue);
|
|
resetText();
|
|
},
|
|
onKeyDown: function onKeyDown(e, preventDefault) {
|
|
_onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(e, preventDefault);
|
|
},
|
|
onFocus: onFocus,
|
|
onBlur: onBlur
|
|
}),
|
|
_usePickerInput2 = (0,slicedToArray/* default */.Z)(_usePickerInput, 2),
|
|
inputProps = _usePickerInput2[0],
|
|
_usePickerInput2$ = _usePickerInput2[1],
|
|
focused = _usePickerInput2$.focused,
|
|
typing = _usePickerInput2$.typing;
|
|
// ============================= Sync ==============================
|
|
// Close should sync back with text value
|
|
react.useEffect(function () {
|
|
if (!mergedOpen) {
|
|
setSelectedValue(mergedValue);
|
|
if (!valueTexts.length || valueTexts[0] === '') {
|
|
triggerTextChange('');
|
|
} else if (firstValueText !== text) {
|
|
resetText();
|
|
}
|
|
}
|
|
}, [mergedOpen, valueTexts]);
|
|
// Change picker should sync back with text value
|
|
react.useEffect(function () {
|
|
if (!mergedOpen) {
|
|
resetText();
|
|
}
|
|
}, [picker]);
|
|
// Sync innerValue with control mode
|
|
react.useEffect(function () {
|
|
// Sync select value
|
|
setSelectedValue(mergedValue);
|
|
}, [mergedValue]);
|
|
// ============================ Private ============================
|
|
if (pickerRef) {
|
|
pickerRef.current = {
|
|
focus: function focus() {
|
|
if (inputRef.current) {
|
|
inputRef.current.focus();
|
|
}
|
|
},
|
|
blur: function blur() {
|
|
if (inputRef.current) {
|
|
inputRef.current.blur();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var _useHoverValue = useHoverValue(text, {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
}),
|
|
_useHoverValue2 = (0,slicedToArray/* default */.Z)(_useHoverValue, 3),
|
|
hoverValue = _useHoverValue2[0],
|
|
onEnter = _useHoverValue2[1],
|
|
onLeave = _useHoverValue2[2];
|
|
// ============================= Panel =============================
|
|
var panelProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
className: undefined,
|
|
style: undefined,
|
|
pickerValue: undefined,
|
|
onPickerValueChange: undefined,
|
|
onChange: null
|
|
});
|
|
var panelNode = /*#__PURE__*/react.createElement(es_PickerPanel, (0,esm_extends/* default */.Z)({}, panelProps, {
|
|
generateConfig: generateConfig,
|
|
className: classnames_default()((0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-panel-focused"), !typing)),
|
|
value: selectedValue,
|
|
locale: locale,
|
|
tabIndex: -1,
|
|
onSelect: function onSelect(date) {
|
|
_onSelect === null || _onSelect === void 0 ? void 0 : _onSelect(date);
|
|
setSelectedValue(date);
|
|
},
|
|
direction: direction,
|
|
onPanelChange: function onPanelChange(viewDate, mode) {
|
|
var onPanelChange = props.onPanelChange;
|
|
onLeave(true);
|
|
onPanelChange === null || onPanelChange === void 0 ? void 0 : onPanelChange(viewDate, mode);
|
|
}
|
|
}));
|
|
if (panelRender) {
|
|
panelNode = panelRender(panelNode);
|
|
}
|
|
var panel = /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-panel-container"),
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
}
|
|
}, panelNode);
|
|
var suffixNode;
|
|
if (suffixIcon) {
|
|
suffixNode = /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-suffix")
|
|
}, suffixIcon);
|
|
}
|
|
var clearNode;
|
|
if (allowClear && mergedValue && !disabled) {
|
|
clearNode = /*#__PURE__*/react.createElement("span", {
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
},
|
|
onMouseUp: function onMouseUp(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
triggerChange(null);
|
|
triggerOpen(false);
|
|
},
|
|
className: "".concat(prefixCls, "-clear"),
|
|
role: "button"
|
|
}, clearIcon || /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-clear-btn")
|
|
}));
|
|
}
|
|
var mergedInputProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
id: id,
|
|
tabIndex: tabIndex,
|
|
disabled: disabled,
|
|
readOnly: inputReadOnly || typeof formatList[0] === 'function' || !typing,
|
|
value: hoverValue || text,
|
|
onChange: function onChange(e) {
|
|
triggerTextChange(e.target.value);
|
|
},
|
|
autoFocus: autoFocus,
|
|
placeholder: placeholder,
|
|
ref: inputRef,
|
|
title: text
|
|
}, inputProps), {}, {
|
|
size: getInputSize(picker, formatList[0], generateConfig)
|
|
}, getDataOrAriaProps(props)), {}, {
|
|
autoComplete: autoComplete
|
|
});
|
|
var inputNode = inputRender ? inputRender(mergedInputProps) : /*#__PURE__*/react.createElement("input", mergedInputProps);
|
|
// ============================ Warning ============================
|
|
if (false) {}
|
|
// ============================ Return =============================
|
|
var onContextSelect = function onContextSelect(date, type) {
|
|
if (type === 'submit' || type !== 'key' && !needConfirmButton) {
|
|
// triggerChange will also update selected values
|
|
triggerChange(date);
|
|
triggerOpen(false);
|
|
}
|
|
};
|
|
var popupPlacement = direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
|
|
return /*#__PURE__*/react.createElement(es_PanelContext.Provider, {
|
|
value: {
|
|
operationRef: operationRef,
|
|
hideHeader: picker === 'time',
|
|
panelRef: panelDivRef,
|
|
onSelect: onContextSelect,
|
|
open: mergedOpen,
|
|
defaultOpenValue: defaultOpenValue,
|
|
onDateMouseEnter: onEnter,
|
|
onDateMouseLeave: onLeave
|
|
}
|
|
}, /*#__PURE__*/react.createElement(es_PickerTrigger, {
|
|
visible: mergedOpen,
|
|
popupElement: panel,
|
|
popupStyle: popupStyle,
|
|
prefixCls: prefixCls,
|
|
dropdownClassName: dropdownClassName,
|
|
dropdownAlign: dropdownAlign,
|
|
getPopupContainer: getPopupContainer,
|
|
transitionName: transitionName,
|
|
popupPlacement: popupPlacement,
|
|
direction: direction
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
ref: containerRef,
|
|
className: classnames_default()(prefixCls, className, (_classNames2 = {}, (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-disabled"), disabled), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-focused"), focused), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames2)),
|
|
style: style,
|
|
onMouseDown: onMouseDown,
|
|
onMouseUp: onMouseUp,
|
|
onMouseEnter: onMouseEnter,
|
|
onMouseLeave: onMouseLeave,
|
|
onContextMenu: onContextMenu,
|
|
onClick: onInternalClick
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()("".concat(prefixCls, "-input"), (0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-input-placeholder"), !!hoverValue)),
|
|
ref: inputDivRef
|
|
}, inputNode, suffixNode, clearNode))));
|
|
}
|
|
// Wrap with class component to enable pass generic with instance method
|
|
var Picker = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(Picker, _React$Component);
|
|
var _super = (0,createSuper/* default */.Z)(Picker);
|
|
function Picker() {
|
|
var _this;
|
|
(0,classCallCheck/* default */.Z)(this, Picker);
|
|
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
args[_key2] = arguments[_key2];
|
|
}
|
|
_this = _super.call.apply(_super, [this].concat(args));
|
|
_this.pickerRef = /*#__PURE__*/react.createRef();
|
|
_this.focus = function () {
|
|
if (_this.pickerRef.current) {
|
|
_this.pickerRef.current.focus();
|
|
}
|
|
};
|
|
_this.blur = function () {
|
|
if (_this.pickerRef.current) {
|
|
_this.pickerRef.current.blur();
|
|
}
|
|
};
|
|
return _this;
|
|
}
|
|
(0,createClass/* default */.Z)(Picker, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return /*#__PURE__*/react.createElement(InnerPicker, (0,esm_extends/* default */.Z)({}, this.props, {
|
|
pickerRef: this.pickerRef
|
|
}));
|
|
}
|
|
}]);
|
|
return Picker;
|
|
}(react.Component);
|
|
/* harmony default export */ var es_Picker = (Picker);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useRangeDisabled.js
|
|
|
|
|
|
|
|
function useRangeDisabled(_ref, disabledStart, disabledEnd) {
|
|
var picker = _ref.picker,
|
|
locale = _ref.locale,
|
|
selectedValue = _ref.selectedValue,
|
|
disabledDate = _ref.disabledDate,
|
|
disabled = _ref.disabled,
|
|
generateConfig = _ref.generateConfig;
|
|
var startDate = getValue(selectedValue, 0);
|
|
var endDate = getValue(selectedValue, 1);
|
|
function weekFirstDate(date) {
|
|
return generateConfig.locale.getWeekFirstDate(locale.locale, date);
|
|
}
|
|
function monthNumber(date) {
|
|
var year = generateConfig.getYear(date);
|
|
var month = generateConfig.getMonth(date);
|
|
return year * 100 + month;
|
|
}
|
|
function quarterNumber(date) {
|
|
var year = generateConfig.getYear(date);
|
|
var quarter = getQuarter(generateConfig, date);
|
|
return year * 10 + quarter;
|
|
}
|
|
var disabledStartDate = react.useCallback(function (date) {
|
|
if (disabledDate && disabledDate(date)) {
|
|
return true;
|
|
}
|
|
// Disabled range
|
|
if (disabled[1] && endDate) {
|
|
return !isSameDate(generateConfig, date, endDate) && generateConfig.isAfter(date, endDate);
|
|
}
|
|
// Disabled part
|
|
if (disabledStart && endDate) {
|
|
switch (picker) {
|
|
case 'quarter':
|
|
return quarterNumber(date) > quarterNumber(endDate);
|
|
case 'month':
|
|
return monthNumber(date) > monthNumber(endDate);
|
|
case 'week':
|
|
return weekFirstDate(date) > weekFirstDate(endDate);
|
|
default:
|
|
return !isSameDate(generateConfig, date, endDate) && generateConfig.isAfter(date, endDate);
|
|
}
|
|
}
|
|
return false;
|
|
}, [disabledDate, disabled[1], endDate, disabledStart]);
|
|
var disabledEndDate = react.useCallback(function (date) {
|
|
if (disabledDate && disabledDate(date)) {
|
|
return true;
|
|
}
|
|
// Disabled range
|
|
if (disabled[0] && startDate) {
|
|
return !isSameDate(generateConfig, date, endDate) && generateConfig.isAfter(startDate, date);
|
|
}
|
|
// Disabled part
|
|
if (disabledEnd && startDate) {
|
|
switch (picker) {
|
|
case 'quarter':
|
|
return quarterNumber(date) < quarterNumber(startDate);
|
|
case 'month':
|
|
return monthNumber(date) < monthNumber(startDate);
|
|
case 'week':
|
|
return weekFirstDate(date) < weekFirstDate(startDate);
|
|
default:
|
|
return !isSameDate(generateConfig, date, startDate) && generateConfig.isAfter(startDate, date);
|
|
}
|
|
}
|
|
return false;
|
|
}, [disabledDate, disabled[0], startDate, disabledEnd]);
|
|
return [disabledStartDate, disabledEndDate];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useRangeViewDates.js
|
|
|
|
|
|
|
|
|
|
function getStartEndDistance(startDate, endDate, picker, generateConfig) {
|
|
var startNext = getClosingViewDate(startDate, picker, generateConfig, 1);
|
|
function getDistance(compareFunc) {
|
|
if (compareFunc(startDate, endDate)) {
|
|
return 'same';
|
|
}
|
|
if (compareFunc(startNext, endDate)) {
|
|
return 'closing';
|
|
}
|
|
return 'far';
|
|
}
|
|
switch (picker) {
|
|
case 'year':
|
|
return getDistance(function (start, end) {
|
|
return isSameDecade(generateConfig, start, end);
|
|
});
|
|
case 'quarter':
|
|
case 'month':
|
|
return getDistance(function (start, end) {
|
|
return isSameYear(generateConfig, start, end);
|
|
});
|
|
default:
|
|
return getDistance(function (start, end) {
|
|
return isSameMonth(generateConfig, start, end);
|
|
});
|
|
}
|
|
}
|
|
function getRangeViewDate(values, index, picker, generateConfig) {
|
|
var startDate = getValue(values, 0);
|
|
var endDate = getValue(values, 1);
|
|
if (index === 0) {
|
|
return startDate;
|
|
}
|
|
if (startDate && endDate) {
|
|
var distance = getStartEndDistance(startDate, endDate, picker, generateConfig);
|
|
switch (distance) {
|
|
case 'same':
|
|
return startDate;
|
|
case 'closing':
|
|
return startDate;
|
|
default:
|
|
return getClosingViewDate(endDate, picker, generateConfig, -1);
|
|
}
|
|
}
|
|
return startDate;
|
|
}
|
|
function useRangeViewDates(_ref) {
|
|
var values = _ref.values,
|
|
picker = _ref.picker,
|
|
defaultDates = _ref.defaultDates,
|
|
generateConfig = _ref.generateConfig;
|
|
var _React$useState = react.useState(function () {
|
|
return [getValue(defaultDates, 0), getValue(defaultDates, 1)];
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
defaultViewDates = _React$useState2[0],
|
|
setDefaultViewDates = _React$useState2[1];
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
viewDates = _React$useState4[0],
|
|
setInternalViewDates = _React$useState4[1];
|
|
var startDate = getValue(values, 0);
|
|
var endDate = getValue(values, 1);
|
|
function getViewDate(index) {
|
|
// If set default view date, use it
|
|
if (defaultViewDates[index]) {
|
|
return defaultViewDates[index];
|
|
}
|
|
return getValue(viewDates, index) || getRangeViewDate(values, index, picker, generateConfig) || startDate || endDate || generateConfig.getNow();
|
|
}
|
|
function setViewDate(viewDate, index) {
|
|
if (viewDate) {
|
|
var newViewDates = updateValues(viewDates, viewDate, index);
|
|
// Set view date will clean up default one
|
|
setDefaultViewDates(
|
|
// Should always be an array
|
|
updateValues(defaultViewDates, null, index) || [null, null]);
|
|
// Reset another one when not have value
|
|
var anotherIndex = (index + 1) % 2;
|
|
if (!getValue(values, anotherIndex)) {
|
|
newViewDates = updateValues(newViewDates, viewDate, anotherIndex);
|
|
}
|
|
setInternalViewDates(newViewDates);
|
|
} else if (startDate || endDate) {
|
|
// Reset all when has values when `viewDate` is `null` which means from open trigger
|
|
setInternalViewDates(null);
|
|
}
|
|
}
|
|
return [getViewDate, setViewDate];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/RangePicker.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function reorderValues(values, generateConfig) {
|
|
if (values && values[0] && values[1] && generateConfig.isAfter(values[0], values[1])) {
|
|
return [values[1], values[0]];
|
|
}
|
|
return values;
|
|
}
|
|
function canValueTrigger(value, index, disabled, allowEmpty) {
|
|
if (value) {
|
|
return true;
|
|
}
|
|
if (allowEmpty && allowEmpty[index]) {
|
|
return true;
|
|
}
|
|
if (disabled[(index + 1) % 2]) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function InnerRangePicker(props) {
|
|
var _classNames2, _classNames3, _classNames4;
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
|
|
id = props.id,
|
|
style = props.style,
|
|
className = props.className,
|
|
popupStyle = props.popupStyle,
|
|
dropdownClassName = props.dropdownClassName,
|
|
transitionName = props.transitionName,
|
|
dropdownAlign = props.dropdownAlign,
|
|
getPopupContainer = props.getPopupContainer,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
placeholder = props.placeholder,
|
|
autoFocus = props.autoFocus,
|
|
disabled = props.disabled,
|
|
format = props.format,
|
|
_props$picker = props.picker,
|
|
picker = _props$picker === void 0 ? 'date' : _props$picker,
|
|
showTime = props.showTime,
|
|
use12Hours = props.use12Hours,
|
|
_props$separator = props.separator,
|
|
separator = _props$separator === void 0 ? '~' : _props$separator,
|
|
value = props.value,
|
|
defaultValue = props.defaultValue,
|
|
defaultPickerValue = props.defaultPickerValue,
|
|
open = props.open,
|
|
defaultOpen = props.defaultOpen,
|
|
disabledDate = props.disabledDate,
|
|
_disabledTime = props.disabledTime,
|
|
dateRender = props.dateRender,
|
|
panelRender = props.panelRender,
|
|
ranges = props.ranges,
|
|
allowEmpty = props.allowEmpty,
|
|
allowClear = props.allowClear,
|
|
suffixIcon = props.suffixIcon,
|
|
clearIcon = props.clearIcon,
|
|
pickerRef = props.pickerRef,
|
|
inputReadOnly = props.inputReadOnly,
|
|
mode = props.mode,
|
|
renderExtraFooter = props.renderExtraFooter,
|
|
onChange = props.onChange,
|
|
onOpenChange = props.onOpenChange,
|
|
onPanelChange = props.onPanelChange,
|
|
onCalendarChange = props.onCalendarChange,
|
|
_onFocus = props.onFocus,
|
|
onBlur = props.onBlur,
|
|
onMouseDown = props.onMouseDown,
|
|
onMouseUp = props.onMouseUp,
|
|
onMouseEnter = props.onMouseEnter,
|
|
onMouseLeave = props.onMouseLeave,
|
|
onClick = props.onClick,
|
|
_onOk = props.onOk,
|
|
_onKeyDown = props.onKeyDown,
|
|
components = props.components,
|
|
order = props.order,
|
|
direction = props.direction,
|
|
activePickerIndex = props.activePickerIndex,
|
|
_props$autoComplete = props.autoComplete,
|
|
autoComplete = _props$autoComplete === void 0 ? 'off' : _props$autoComplete;
|
|
var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
|
|
// We record opened status here in case repeat open with picker
|
|
var openRecordsRef = (0,react.useRef)({});
|
|
var containerRef = (0,react.useRef)(null);
|
|
var panelDivRef = (0,react.useRef)(null);
|
|
var startInputDivRef = (0,react.useRef)(null);
|
|
var endInputDivRef = (0,react.useRef)(null);
|
|
var separatorRef = (0,react.useRef)(null);
|
|
var startInputRef = (0,react.useRef)(null);
|
|
var endInputRef = (0,react.useRef)(null);
|
|
var arrowRef = (0,react.useRef)(null);
|
|
// ============================ Warning ============================
|
|
if (false) {}
|
|
// ============================= Misc ==============================
|
|
var formatList = toArray(getDefaultFormat(format, picker, showTime, use12Hours));
|
|
// Active picker
|
|
var _useMergedState = (0,useMergedState/* default */.Z)(0, {
|
|
value: activePickerIndex
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
mergedActivePickerIndex = _useMergedState2[0],
|
|
setMergedActivePickerIndex = _useMergedState2[1];
|
|
// Operation ref
|
|
var operationRef = (0,react.useRef)(null);
|
|
var mergedDisabled = react.useMemo(function () {
|
|
if (Array.isArray(disabled)) {
|
|
return disabled;
|
|
}
|
|
return [disabled || false, disabled || false];
|
|
}, [disabled]);
|
|
// ============================= Value =============================
|
|
var _useMergedState3 = (0,useMergedState/* default */.Z)(null, {
|
|
value: value,
|
|
defaultValue: defaultValue,
|
|
postState: function postState(values) {
|
|
return picker === 'time' && !order ? values : reorderValues(values, generateConfig);
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
mergedValue = _useMergedState4[0],
|
|
setInnerValue = _useMergedState4[1];
|
|
// =========================== View Date ===========================
|
|
// Config view panel
|
|
var _useRangeViewDates = useRangeViewDates({
|
|
values: mergedValue,
|
|
picker: picker,
|
|
defaultDates: defaultPickerValue,
|
|
generateConfig: generateConfig
|
|
}),
|
|
_useRangeViewDates2 = (0,slicedToArray/* default */.Z)(_useRangeViewDates, 2),
|
|
getViewDate = _useRangeViewDates2[0],
|
|
setViewDate = _useRangeViewDates2[1];
|
|
// ========================= Select Values =========================
|
|
var _useMergedState5 = (0,useMergedState/* default */.Z)(mergedValue, {
|
|
postState: function postState(values) {
|
|
var postValues = values;
|
|
if (mergedDisabled[0] && mergedDisabled[1]) {
|
|
return postValues;
|
|
}
|
|
// Fill disabled unit
|
|
for (var i = 0; i < 2; i += 1) {
|
|
if (mergedDisabled[i] && !getValue(postValues, i) && !getValue(allowEmpty, i)) {
|
|
postValues = updateValues(postValues, generateConfig.getNow(), i);
|
|
}
|
|
}
|
|
return postValues;
|
|
}
|
|
}),
|
|
_useMergedState6 = (0,slicedToArray/* default */.Z)(_useMergedState5, 2),
|
|
selectedValue = _useMergedState6[0],
|
|
setSelectedValue = _useMergedState6[1];
|
|
// ============================= Modes =============================
|
|
var _useMergedState7 = (0,useMergedState/* default */.Z)([picker, picker], {
|
|
value: mode
|
|
}),
|
|
_useMergedState8 = (0,slicedToArray/* default */.Z)(_useMergedState7, 2),
|
|
mergedModes = _useMergedState8[0],
|
|
setInnerModes = _useMergedState8[1];
|
|
(0,react.useEffect)(function () {
|
|
setInnerModes([picker, picker]);
|
|
}, [picker]);
|
|
var triggerModesChange = function triggerModesChange(modes, values) {
|
|
setInnerModes(modes);
|
|
if (onPanelChange) {
|
|
onPanelChange(values, modes);
|
|
}
|
|
};
|
|
// ========================= Disable Date ==========================
|
|
var _useRangeDisabled = useRangeDisabled({
|
|
picker: picker,
|
|
selectedValue: selectedValue,
|
|
locale: locale,
|
|
disabled: mergedDisabled,
|
|
disabledDate: disabledDate,
|
|
generateConfig: generateConfig
|
|
}, openRecordsRef.current[1], openRecordsRef.current[0]),
|
|
_useRangeDisabled2 = (0,slicedToArray/* default */.Z)(_useRangeDisabled, 2),
|
|
disabledStartDate = _useRangeDisabled2[0],
|
|
disabledEndDate = _useRangeDisabled2[1];
|
|
// ============================= Open ==============================
|
|
var _useMergedState9 = (0,useMergedState/* default */.Z)(false, {
|
|
value: open,
|
|
defaultValue: defaultOpen,
|
|
postState: function postState(postOpen) {
|
|
return mergedDisabled[mergedActivePickerIndex] ? false : postOpen;
|
|
},
|
|
onChange: function onChange(newOpen) {
|
|
if (onOpenChange) {
|
|
onOpenChange(newOpen);
|
|
}
|
|
if (!newOpen && operationRef.current && operationRef.current.onClose) {
|
|
operationRef.current.onClose();
|
|
}
|
|
}
|
|
}),
|
|
_useMergedState10 = (0,slicedToArray/* default */.Z)(_useMergedState9, 2),
|
|
mergedOpen = _useMergedState10[0],
|
|
triggerInnerOpen = _useMergedState10[1];
|
|
var startOpen = mergedOpen && mergedActivePickerIndex === 0;
|
|
var endOpen = mergedOpen && mergedActivePickerIndex === 1;
|
|
// ============================= Popup =============================
|
|
// Popup min width
|
|
var _useState = (0,react.useState)(0),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
popupMinWidth = _useState2[0],
|
|
setPopupMinWidth = _useState2[1];
|
|
(0,react.useEffect)(function () {
|
|
if (!mergedOpen && containerRef.current) {
|
|
setPopupMinWidth(containerRef.current.offsetWidth);
|
|
}
|
|
}, [mergedOpen]);
|
|
// ============================ Trigger ============================
|
|
var triggerRef = react.useRef();
|
|
function _triggerOpen(newOpen, index) {
|
|
if (newOpen) {
|
|
clearTimeout(triggerRef.current);
|
|
openRecordsRef.current[index] = true;
|
|
setMergedActivePickerIndex(index);
|
|
triggerInnerOpen(newOpen);
|
|
// Open to reset view date
|
|
if (!mergedOpen) {
|
|
setViewDate(null, index);
|
|
}
|
|
} else if (mergedActivePickerIndex === index) {
|
|
triggerInnerOpen(newOpen);
|
|
// Clean up async
|
|
// This makes ref not quick refresh in case user open another input with blur trigger
|
|
var openRecords = openRecordsRef.current;
|
|
triggerRef.current = setTimeout(function () {
|
|
if (openRecords === openRecordsRef.current) {
|
|
openRecordsRef.current = {};
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function triggerOpenAndFocus(index) {
|
|
_triggerOpen(true, index);
|
|
// Use setTimeout to make sure panel DOM exists
|
|
setTimeout(function () {
|
|
var inputRef = [startInputRef, endInputRef][index];
|
|
if (inputRef.current) {
|
|
inputRef.current.focus();
|
|
}
|
|
}, 0);
|
|
}
|
|
function triggerChange(newValue, sourceIndex) {
|
|
var values = newValue;
|
|
var startValue = getValue(values, 0);
|
|
var endValue = getValue(values, 1);
|
|
// >>>>> Format start & end values
|
|
if (startValue && endValue && generateConfig.isAfter(startValue, endValue)) {
|
|
if (
|
|
// WeekPicker only compare week
|
|
picker === 'week' && !isSameWeek(generateConfig, locale.locale, startValue, endValue) ||
|
|
// QuotaPicker only compare week
|
|
picker === 'quarter' && !isSameQuarter(generateConfig, startValue, endValue) ||
|
|
// Other non-TimePicker compare date
|
|
picker !== 'week' && picker !== 'quarter' && picker !== 'time' && !isSameDate(generateConfig, startValue, endValue)) {
|
|
// Clean up end date when start date is after end date
|
|
if (sourceIndex === 0) {
|
|
values = [startValue, null];
|
|
endValue = null;
|
|
} else {
|
|
startValue = null;
|
|
values = [null, endValue];
|
|
}
|
|
// Clean up cache since invalidate
|
|
openRecordsRef.current = (0,defineProperty/* default */.Z)({}, sourceIndex, true);
|
|
} else if (picker !== 'time' || order !== false) {
|
|
// Reorder when in same date
|
|
values = reorderValues(values, generateConfig);
|
|
}
|
|
}
|
|
setSelectedValue(values);
|
|
var startStr = values && values[0] ? formatValue(values[0], {
|
|
generateConfig: generateConfig,
|
|
locale: locale,
|
|
format: formatList[0]
|
|
}) : '';
|
|
var endStr = values && values[1] ? formatValue(values[1], {
|
|
generateConfig: generateConfig,
|
|
locale: locale,
|
|
format: formatList[0]
|
|
}) : '';
|
|
if (onCalendarChange) {
|
|
var info = {
|
|
range: sourceIndex === 0 ? 'start' : 'end'
|
|
};
|
|
onCalendarChange(values, [startStr, endStr], info);
|
|
}
|
|
// >>>>> Trigger `onChange` event
|
|
var canStartValueTrigger = canValueTrigger(startValue, 0, mergedDisabled, allowEmpty);
|
|
var canEndValueTrigger = canValueTrigger(endValue, 1, mergedDisabled, allowEmpty);
|
|
var canTrigger = values === null || canStartValueTrigger && canEndValueTrigger;
|
|
if (canTrigger) {
|
|
// Trigger onChange only when value is validate
|
|
setInnerValue(values);
|
|
if (onChange && (!isEqual(generateConfig, getValue(mergedValue, 0), startValue) || !isEqual(generateConfig, getValue(mergedValue, 1), endValue))) {
|
|
onChange(values, [startStr, endStr]);
|
|
}
|
|
}
|
|
// >>>>> Open picker when
|
|
// Always open another picker if possible
|
|
var nextOpenIndex = null;
|
|
if (sourceIndex === 0 && !mergedDisabled[1]) {
|
|
nextOpenIndex = 1;
|
|
} else if (sourceIndex === 1 && !mergedDisabled[0]) {
|
|
nextOpenIndex = 0;
|
|
}
|
|
if (nextOpenIndex !== null && nextOpenIndex !== mergedActivePickerIndex && (!openRecordsRef.current[nextOpenIndex] || !getValue(values, nextOpenIndex)) && getValue(values, sourceIndex)) {
|
|
// Delay to focus to avoid input blur trigger expired selectedValues
|
|
triggerOpenAndFocus(nextOpenIndex);
|
|
} else {
|
|
_triggerOpen(false, sourceIndex);
|
|
}
|
|
}
|
|
var forwardKeyDown = function forwardKeyDown(e) {
|
|
if (mergedOpen && operationRef.current && operationRef.current.onKeyDown) {
|
|
// Let popup panel handle keyboard
|
|
return operationRef.current.onKeyDown(e);
|
|
}
|
|
/* istanbul ignore next */
|
|
/* eslint-disable no-lone-blocks */
|
|
{
|
|
(0,es_warning/* default */.ZP)(false, 'Picker not correct forward KeyDown operation. Please help to fire issue about this.');
|
|
return false;
|
|
}
|
|
};
|
|
// ============================= Text ==============================
|
|
var sharedTextHooksProps = {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
};
|
|
var _useValueTexts = useValueTexts(getValue(selectedValue, 0), sharedTextHooksProps),
|
|
_useValueTexts2 = (0,slicedToArray/* default */.Z)(_useValueTexts, 2),
|
|
startValueTexts = _useValueTexts2[0],
|
|
firstStartValueText = _useValueTexts2[1];
|
|
var _useValueTexts3 = useValueTexts(getValue(selectedValue, 1), sharedTextHooksProps),
|
|
_useValueTexts4 = (0,slicedToArray/* default */.Z)(_useValueTexts3, 2),
|
|
endValueTexts = _useValueTexts4[0],
|
|
firstEndValueText = _useValueTexts4[1];
|
|
var _onTextChange = function onTextChange(newText, index) {
|
|
var inputDate = parseValue(newText, {
|
|
locale: locale,
|
|
formatList: formatList,
|
|
generateConfig: generateConfig
|
|
});
|
|
var disabledFunc = index === 0 ? disabledStartDate : disabledEndDate;
|
|
if (inputDate && !disabledFunc(inputDate)) {
|
|
setSelectedValue(updateValues(selectedValue, inputDate, index));
|
|
setViewDate(inputDate, index);
|
|
}
|
|
};
|
|
var _useTextValueMapping = useTextValueMapping({
|
|
valueTexts: startValueTexts,
|
|
onTextChange: function onTextChange(newText) {
|
|
return _onTextChange(newText, 0);
|
|
}
|
|
}),
|
|
_useTextValueMapping2 = (0,slicedToArray/* default */.Z)(_useTextValueMapping, 3),
|
|
startText = _useTextValueMapping2[0],
|
|
triggerStartTextChange = _useTextValueMapping2[1],
|
|
resetStartText = _useTextValueMapping2[2];
|
|
var _useTextValueMapping3 = useTextValueMapping({
|
|
valueTexts: endValueTexts,
|
|
onTextChange: function onTextChange(newText) {
|
|
return _onTextChange(newText, 1);
|
|
}
|
|
}),
|
|
_useTextValueMapping4 = (0,slicedToArray/* default */.Z)(_useTextValueMapping3, 3),
|
|
endText = _useTextValueMapping4[0],
|
|
triggerEndTextChange = _useTextValueMapping4[1],
|
|
resetEndText = _useTextValueMapping4[2];
|
|
var _useState3 = (0,react.useState)(null),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
rangeHoverValue = _useState4[0],
|
|
setRangeHoverValue = _useState4[1];
|
|
// ========================== Hover Range ==========================
|
|
var _useState5 = (0,react.useState)(null),
|
|
_useState6 = (0,slicedToArray/* default */.Z)(_useState5, 2),
|
|
hoverRangedValue = _useState6[0],
|
|
setHoverRangedValue = _useState6[1];
|
|
var _useHoverValue = useHoverValue(startText, {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
}),
|
|
_useHoverValue2 = (0,slicedToArray/* default */.Z)(_useHoverValue, 3),
|
|
startHoverValue = _useHoverValue2[0],
|
|
onStartEnter = _useHoverValue2[1],
|
|
onStartLeave = _useHoverValue2[2];
|
|
var _useHoverValue3 = useHoverValue(endText, {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
}),
|
|
_useHoverValue4 = (0,slicedToArray/* default */.Z)(_useHoverValue3, 3),
|
|
endHoverValue = _useHoverValue4[0],
|
|
onEndEnter = _useHoverValue4[1],
|
|
onEndLeave = _useHoverValue4[2];
|
|
var onDateMouseEnter = function onDateMouseEnter(date) {
|
|
setHoverRangedValue(updateValues(selectedValue, date, mergedActivePickerIndex));
|
|
if (mergedActivePickerIndex === 0) {
|
|
onStartEnter(date);
|
|
} else {
|
|
onEndEnter(date);
|
|
}
|
|
};
|
|
var onDateMouseLeave = function onDateMouseLeave() {
|
|
setHoverRangedValue(updateValues(selectedValue, null, mergedActivePickerIndex));
|
|
if (mergedActivePickerIndex === 0) {
|
|
onStartLeave();
|
|
} else {
|
|
onEndLeave();
|
|
}
|
|
};
|
|
// ============================= Input =============================
|
|
var getSharedInputHookProps = function getSharedInputHookProps(index, resetText) {
|
|
return {
|
|
blurToCancel: needConfirmButton,
|
|
forwardKeyDown: forwardKeyDown,
|
|
onBlur: onBlur,
|
|
isClickOutside: function isClickOutside(target) {
|
|
return !elementsContains([panelDivRef.current, startInputDivRef.current, endInputDivRef.current, containerRef.current], target);
|
|
},
|
|
onFocus: function onFocus(e) {
|
|
setMergedActivePickerIndex(index);
|
|
if (_onFocus) {
|
|
_onFocus(e);
|
|
}
|
|
},
|
|
triggerOpen: function triggerOpen(newOpen) {
|
|
_triggerOpen(newOpen, index);
|
|
},
|
|
onSubmit: function onSubmit() {
|
|
if (
|
|
// When user typing disabledDate with keyboard and enter, this value will be empty
|
|
!selectedValue ||
|
|
// Normal disabled check
|
|
disabledDate && disabledDate(selectedValue[index])) {
|
|
return false;
|
|
}
|
|
triggerChange(selectedValue, index);
|
|
resetText();
|
|
},
|
|
onCancel: function onCancel() {
|
|
_triggerOpen(false, index);
|
|
setSelectedValue(mergedValue);
|
|
resetText();
|
|
}
|
|
};
|
|
};
|
|
var currentFocusedKey = (0,react.useRef)('');
|
|
var _usePickerInput = usePickerInput((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, getSharedInputHookProps(0, resetStartText)), {}, {
|
|
open: startOpen,
|
|
value: startText,
|
|
currentFocusedKey: currentFocusedKey,
|
|
key: 'start',
|
|
onKeyDown: function onKeyDown(e, preventDefault) {
|
|
_onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(e, preventDefault);
|
|
}
|
|
})),
|
|
_usePickerInput2 = (0,slicedToArray/* default */.Z)(_usePickerInput, 2),
|
|
startInputProps = _usePickerInput2[0],
|
|
_usePickerInput2$ = _usePickerInput2[1],
|
|
startFocused = _usePickerInput2$.focused,
|
|
startTyping = _usePickerInput2$.typing;
|
|
var _usePickerInput3 = usePickerInput((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, getSharedInputHookProps(1, resetEndText)), {}, {
|
|
open: endOpen,
|
|
value: endText,
|
|
currentFocusedKey: currentFocusedKey,
|
|
key: 'end',
|
|
onKeyDown: function onKeyDown(e, preventDefault) {
|
|
_onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(e, preventDefault);
|
|
}
|
|
})),
|
|
_usePickerInput4 = (0,slicedToArray/* default */.Z)(_usePickerInput3, 2),
|
|
endInputProps = _usePickerInput4[0],
|
|
_usePickerInput4$ = _usePickerInput4[1],
|
|
endFocused = _usePickerInput4$.focused,
|
|
endTyping = _usePickerInput4$.typing;
|
|
// ========================== Click Picker ==========================
|
|
var onPickerClick = function onPickerClick(e) {
|
|
// When click inside the picker & outside the picker's input elements
|
|
// the panel should still be opened
|
|
if (onClick) {
|
|
onClick(e);
|
|
}
|
|
if (!mergedOpen && !startInputRef.current.contains(e.target) && !endInputRef.current.contains(e.target)) {
|
|
if (!mergedDisabled[0]) {
|
|
triggerOpenAndFocus(0);
|
|
} else if (!mergedDisabled[1]) {
|
|
triggerOpenAndFocus(1);
|
|
}
|
|
}
|
|
};
|
|
var onPickerMouseDown = function onPickerMouseDown(e) {
|
|
// shouldn't affect input elements if picker is active
|
|
if (onMouseDown) {
|
|
onMouseDown(e);
|
|
}
|
|
if (mergedOpen && (startFocused || endFocused) && !startInputRef.current.contains(e.target) && !endInputRef.current.contains(e.target)) {
|
|
e.preventDefault();
|
|
}
|
|
};
|
|
// ============================= Sync ==============================
|
|
// Close should sync back with text value
|
|
var startStr = mergedValue && mergedValue[0] ? formatValue(mergedValue[0], {
|
|
locale: locale,
|
|
format: 'YYYYMMDDHHmmss',
|
|
generateConfig: generateConfig
|
|
}) : '';
|
|
var endStr = mergedValue && mergedValue[1] ? formatValue(mergedValue[1], {
|
|
locale: locale,
|
|
format: 'YYYYMMDDHHmmss',
|
|
generateConfig: generateConfig
|
|
}) : '';
|
|
(0,react.useEffect)(function () {
|
|
if (!mergedOpen) {
|
|
setSelectedValue(mergedValue);
|
|
if (!startValueTexts.length || startValueTexts[0] === '') {
|
|
triggerStartTextChange('');
|
|
} else if (firstStartValueText !== startText) {
|
|
resetStartText();
|
|
}
|
|
if (!endValueTexts.length || endValueTexts[0] === '') {
|
|
triggerEndTextChange('');
|
|
} else if (firstEndValueText !== endText) {
|
|
resetEndText();
|
|
}
|
|
}
|
|
}, [mergedOpen, startValueTexts, endValueTexts]);
|
|
// Sync innerValue with control mode
|
|
(0,react.useEffect)(function () {
|
|
setSelectedValue(mergedValue);
|
|
}, [startStr, endStr]);
|
|
// ============================ Warning ============================
|
|
if (false) {}
|
|
// ============================ Private ============================
|
|
if (pickerRef) {
|
|
pickerRef.current = {
|
|
focus: function focus() {
|
|
if (startInputRef.current) {
|
|
startInputRef.current.focus();
|
|
}
|
|
},
|
|
blur: function blur() {
|
|
if (startInputRef.current) {
|
|
startInputRef.current.blur();
|
|
}
|
|
if (endInputRef.current) {
|
|
endInputRef.current.blur();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
// ============================ Ranges =============================
|
|
var rangeLabels = Object.keys(ranges || {});
|
|
var rangeList = rangeLabels.map(function (label) {
|
|
var range = ranges[label];
|
|
var newValues = typeof range === 'function' ? range() : range;
|
|
return {
|
|
label: label,
|
|
onClick: function onClick() {
|
|
triggerChange(newValues, null);
|
|
_triggerOpen(false, mergedActivePickerIndex);
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
setRangeHoverValue(newValues);
|
|
},
|
|
onMouseLeave: function onMouseLeave() {
|
|
setRangeHoverValue(null);
|
|
}
|
|
};
|
|
});
|
|
// ============================= Panel =============================
|
|
function renderPanel() {
|
|
var panelPosition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
var panelProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var panelHoverRangedValue = null;
|
|
if (mergedOpen && hoverRangedValue && hoverRangedValue[0] && hoverRangedValue[1] && generateConfig.isAfter(hoverRangedValue[1], hoverRangedValue[0])) {
|
|
panelHoverRangedValue = hoverRangedValue;
|
|
}
|
|
var panelShowTime = showTime;
|
|
if (showTime && (0,esm_typeof/* default */.Z)(showTime) === 'object' && showTime.defaultValue) {
|
|
var timeDefaultValues = showTime.defaultValue;
|
|
panelShowTime = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, showTime), {}, {
|
|
defaultValue: getValue(timeDefaultValues, mergedActivePickerIndex) || undefined
|
|
});
|
|
}
|
|
var panelDateRender = null;
|
|
if (dateRender) {
|
|
panelDateRender = function panelDateRender(date, today) {
|
|
return dateRender(date, today, {
|
|
range: mergedActivePickerIndex ? 'end' : 'start'
|
|
});
|
|
};
|
|
}
|
|
return /*#__PURE__*/react.createElement(es_RangeContext.Provider, {
|
|
value: {
|
|
inRange: true,
|
|
panelPosition: panelPosition,
|
|
rangedValue: rangeHoverValue || selectedValue,
|
|
hoverRangedValue: panelHoverRangedValue
|
|
}
|
|
}, /*#__PURE__*/react.createElement(es_PickerPanel, (0,esm_extends/* default */.Z)({}, props, panelProps, {
|
|
dateRender: panelDateRender,
|
|
showTime: panelShowTime,
|
|
mode: mergedModes[mergedActivePickerIndex],
|
|
generateConfig: generateConfig,
|
|
style: undefined,
|
|
direction: direction,
|
|
disabledDate: mergedActivePickerIndex === 0 ? disabledStartDate : disabledEndDate,
|
|
disabledTime: function disabledTime(date) {
|
|
if (_disabledTime) {
|
|
return _disabledTime(date, mergedActivePickerIndex === 0 ? 'start' : 'end');
|
|
}
|
|
return false;
|
|
},
|
|
className: classnames_default()((0,defineProperty/* default */.Z)({}, "".concat(prefixCls, "-panel-focused"), mergedActivePickerIndex === 0 ? !startTyping : !endTyping)),
|
|
value: getValue(selectedValue, mergedActivePickerIndex),
|
|
locale: locale,
|
|
tabIndex: -1,
|
|
onPanelChange: function onPanelChange(date, newMode) {
|
|
// clear hover value when panel change
|
|
if (mergedActivePickerIndex === 0) {
|
|
onStartLeave(true);
|
|
}
|
|
if (mergedActivePickerIndex === 1) {
|
|
onEndLeave(true);
|
|
}
|
|
triggerModesChange(updateValues(mergedModes, newMode, mergedActivePickerIndex), updateValues(selectedValue, date, mergedActivePickerIndex));
|
|
var viewDate = date;
|
|
if (panelPosition === 'right' && mergedModes[mergedActivePickerIndex] === newMode) {
|
|
viewDate = getClosingViewDate(viewDate, newMode, generateConfig, -1);
|
|
}
|
|
setViewDate(viewDate, mergedActivePickerIndex);
|
|
},
|
|
onOk: null,
|
|
onSelect: undefined,
|
|
onChange: undefined,
|
|
defaultValue: mergedActivePickerIndex === 0 ? getValue(selectedValue, 1) : getValue(selectedValue, 0)
|
|
})));
|
|
}
|
|
var arrowLeft = 0;
|
|
var panelLeft = 0;
|
|
if (mergedActivePickerIndex && startInputDivRef.current && separatorRef.current && panelDivRef.current) {
|
|
// Arrow offset
|
|
arrowLeft = startInputDivRef.current.offsetWidth + separatorRef.current.offsetWidth;
|
|
// If panelWidth - arrowWidth - arrowMarginLeft < arrowLeft, panel should move to right side.
|
|
// If arrowOffsetLeft > arrowLeft, arrowMarginLeft = arrowOffsetLeft - arrowLeft
|
|
var arrowMarginLeft = arrowRef.current.offsetLeft > arrowLeft ? arrowRef.current.offsetLeft - arrowLeft : arrowRef.current.offsetLeft;
|
|
if (panelDivRef.current.offsetWidth && arrowRef.current.offsetWidth && arrowLeft > panelDivRef.current.offsetWidth - arrowRef.current.offsetWidth - (direction === 'rtl' ? 0 : arrowMarginLeft)) {
|
|
panelLeft = arrowLeft;
|
|
}
|
|
}
|
|
var arrowPositionStyle = direction === 'rtl' ? {
|
|
right: arrowLeft
|
|
} : {
|
|
left: arrowLeft
|
|
};
|
|
function renderPanels() {
|
|
var panels;
|
|
var extraNode = getExtraFooter(prefixCls, mergedModes[mergedActivePickerIndex], renderExtraFooter);
|
|
var rangesNode = getRanges({
|
|
prefixCls: prefixCls,
|
|
components: components,
|
|
needConfirmButton: needConfirmButton,
|
|
okDisabled: !getValue(selectedValue, mergedActivePickerIndex) || disabledDate && disabledDate(selectedValue[mergedActivePickerIndex]),
|
|
locale: locale,
|
|
rangeList: rangeList,
|
|
onOk: function onOk() {
|
|
if (getValue(selectedValue, mergedActivePickerIndex)) {
|
|
// triggerChangeOld(selectedValue);
|
|
triggerChange(selectedValue, mergedActivePickerIndex);
|
|
if (_onOk) {
|
|
_onOk(selectedValue);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (picker !== 'time' && !showTime) {
|
|
var viewDate = getViewDate(mergedActivePickerIndex);
|
|
var nextViewDate = getClosingViewDate(viewDate, picker, generateConfig);
|
|
var currentMode = mergedModes[mergedActivePickerIndex];
|
|
var showDoublePanel = currentMode === picker;
|
|
var leftPanel = renderPanel(showDoublePanel ? 'left' : false, {
|
|
pickerValue: viewDate,
|
|
onPickerValueChange: function onPickerValueChange(newViewDate) {
|
|
setViewDate(newViewDate, mergedActivePickerIndex);
|
|
}
|
|
});
|
|
var rightPanel = renderPanel('right', {
|
|
pickerValue: nextViewDate,
|
|
onPickerValueChange: function onPickerValueChange(newViewDate) {
|
|
setViewDate(getClosingViewDate(newViewDate, picker, generateConfig, -1), mergedActivePickerIndex);
|
|
}
|
|
});
|
|
if (direction === 'rtl') {
|
|
panels = /*#__PURE__*/react.createElement(react.Fragment, null, rightPanel, showDoublePanel && leftPanel);
|
|
} else {
|
|
panels = /*#__PURE__*/react.createElement(react.Fragment, null, leftPanel, showDoublePanel && rightPanel);
|
|
}
|
|
} else {
|
|
panels = renderPanel();
|
|
}
|
|
var mergedNodes = /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-panels")
|
|
}, panels), (extraNode || rangesNode) && /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-footer")
|
|
}, extraNode, rangesNode));
|
|
if (panelRender) {
|
|
mergedNodes = panelRender(mergedNodes);
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-panel-container"),
|
|
style: {
|
|
marginLeft: panelLeft
|
|
},
|
|
ref: panelDivRef,
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
}
|
|
}, mergedNodes);
|
|
}
|
|
var rangePanel = /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()("".concat(prefixCls, "-range-wrapper"), "".concat(prefixCls, "-").concat(picker, "-range-wrapper")),
|
|
style: {
|
|
minWidth: popupMinWidth
|
|
}
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
ref: arrowRef,
|
|
className: "".concat(prefixCls, "-range-arrow"),
|
|
style: arrowPositionStyle
|
|
}), renderPanels());
|
|
// ============================= Icons =============================
|
|
var suffixNode;
|
|
if (suffixIcon) {
|
|
suffixNode = /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-suffix")
|
|
}, suffixIcon);
|
|
}
|
|
var clearNode;
|
|
if (allowClear && (getValue(mergedValue, 0) && !mergedDisabled[0] || getValue(mergedValue, 1) && !mergedDisabled[1])) {
|
|
clearNode = /*#__PURE__*/react.createElement("span", {
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
},
|
|
onMouseUp: function onMouseUp(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
var values = mergedValue;
|
|
if (!mergedDisabled[0]) {
|
|
values = updateValues(values, null, 0);
|
|
}
|
|
if (!mergedDisabled[1]) {
|
|
values = updateValues(values, null, 1);
|
|
}
|
|
triggerChange(values, null);
|
|
_triggerOpen(false, mergedActivePickerIndex);
|
|
},
|
|
className: "".concat(prefixCls, "-clear")
|
|
}, clearIcon || /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-clear-btn")
|
|
}));
|
|
}
|
|
var inputSharedProps = {
|
|
size: getInputSize(picker, formatList[0], generateConfig)
|
|
};
|
|
var activeBarLeft = 0;
|
|
var activeBarWidth = 0;
|
|
if (startInputDivRef.current && endInputDivRef.current && separatorRef.current) {
|
|
if (mergedActivePickerIndex === 0) {
|
|
activeBarWidth = startInputDivRef.current.offsetWidth;
|
|
} else {
|
|
activeBarLeft = arrowLeft;
|
|
activeBarWidth = endInputDivRef.current.offsetWidth;
|
|
}
|
|
}
|
|
var activeBarPositionStyle = direction === 'rtl' ? {
|
|
right: activeBarLeft
|
|
} : {
|
|
left: activeBarLeft
|
|
};
|
|
// ============================ Return =============================
|
|
var onContextSelect = function onContextSelect(date, type) {
|
|
var values = updateValues(selectedValue, date, mergedActivePickerIndex);
|
|
if (type === 'submit' || type !== 'key' && !needConfirmButton) {
|
|
// triggerChange will also update selected values
|
|
triggerChange(values, mergedActivePickerIndex);
|
|
// clear hover value style
|
|
if (mergedActivePickerIndex === 0) {
|
|
onStartLeave();
|
|
} else {
|
|
onEndLeave();
|
|
}
|
|
} else {
|
|
setSelectedValue(values);
|
|
}
|
|
};
|
|
return /*#__PURE__*/react.createElement(es_PanelContext.Provider, {
|
|
value: {
|
|
operationRef: operationRef,
|
|
hideHeader: picker === 'time',
|
|
onDateMouseEnter: onDateMouseEnter,
|
|
onDateMouseLeave: onDateMouseLeave,
|
|
hideRanges: true,
|
|
onSelect: onContextSelect,
|
|
open: mergedOpen
|
|
}
|
|
}, /*#__PURE__*/react.createElement(es_PickerTrigger, {
|
|
visible: mergedOpen,
|
|
popupElement: rangePanel,
|
|
popupStyle: popupStyle,
|
|
prefixCls: prefixCls,
|
|
dropdownClassName: dropdownClassName,
|
|
dropdownAlign: dropdownAlign,
|
|
getPopupContainer: getPopupContainer,
|
|
transitionName: transitionName,
|
|
range: true,
|
|
direction: direction
|
|
}, /*#__PURE__*/react.createElement("div", (0,esm_extends/* default */.Z)({
|
|
ref: containerRef,
|
|
className: classnames_default()(prefixCls, "".concat(prefixCls, "-range"), className, (_classNames2 = {}, (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-disabled"), mergedDisabled[0] && mergedDisabled[1]), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-focused"), mergedActivePickerIndex === 0 ? startFocused : endFocused), (0,defineProperty/* default */.Z)(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames2)),
|
|
style: style,
|
|
onClick: onPickerClick,
|
|
onMouseEnter: onMouseEnter,
|
|
onMouseLeave: onMouseLeave,
|
|
onMouseDown: onPickerMouseDown,
|
|
onMouseUp: onMouseUp
|
|
}, getDataOrAriaProps(props)), /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()("".concat(prefixCls, "-input"), (_classNames3 = {}, (0,defineProperty/* default */.Z)(_classNames3, "".concat(prefixCls, "-input-active"), mergedActivePickerIndex === 0), (0,defineProperty/* default */.Z)(_classNames3, "".concat(prefixCls, "-input-placeholder"), !!startHoverValue), _classNames3)),
|
|
ref: startInputDivRef
|
|
}, /*#__PURE__*/react.createElement("input", (0,esm_extends/* default */.Z)({
|
|
id: id,
|
|
disabled: mergedDisabled[0],
|
|
readOnly: inputReadOnly || typeof formatList[0] === 'function' || !startTyping,
|
|
value: startHoverValue || startText,
|
|
onChange: function onChange(e) {
|
|
triggerStartTextChange(e.target.value);
|
|
},
|
|
autoFocus: autoFocus,
|
|
placeholder: getValue(placeholder, 0) || '',
|
|
ref: startInputRef
|
|
}, startInputProps, inputSharedProps, {
|
|
autoComplete: autoComplete
|
|
}))), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-range-separator"),
|
|
ref: separatorRef
|
|
}, separator), /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()("".concat(prefixCls, "-input"), (_classNames4 = {}, (0,defineProperty/* default */.Z)(_classNames4, "".concat(prefixCls, "-input-active"), mergedActivePickerIndex === 1), (0,defineProperty/* default */.Z)(_classNames4, "".concat(prefixCls, "-input-placeholder"), !!endHoverValue), _classNames4)),
|
|
ref: endInputDivRef
|
|
}, /*#__PURE__*/react.createElement("input", (0,esm_extends/* default */.Z)({
|
|
disabled: mergedDisabled[1],
|
|
readOnly: inputReadOnly || typeof formatList[0] === 'function' || !endTyping,
|
|
value: endHoverValue || endText,
|
|
onChange: function onChange(e) {
|
|
triggerEndTextChange(e.target.value);
|
|
},
|
|
placeholder: getValue(placeholder, 1) || '',
|
|
ref: endInputRef
|
|
}, endInputProps, inputSharedProps, {
|
|
autoComplete: autoComplete
|
|
}))), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-active-bar"),
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, activeBarPositionStyle), {}, {
|
|
width: activeBarWidth,
|
|
position: 'absolute'
|
|
})
|
|
}), suffixNode, clearNode)));
|
|
}
|
|
// Wrap with class component to enable pass generic with instance method
|
|
var RangePicker = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(RangePicker, _React$Component);
|
|
var _super = (0,createSuper/* default */.Z)(RangePicker);
|
|
function RangePicker() {
|
|
var _this;
|
|
(0,classCallCheck/* default */.Z)(this, RangePicker);
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
_this = _super.call.apply(_super, [this].concat(args));
|
|
_this.pickerRef = /*#__PURE__*/react.createRef();
|
|
_this.focus = function () {
|
|
if (_this.pickerRef.current) {
|
|
_this.pickerRef.current.focus();
|
|
}
|
|
};
|
|
_this.blur = function () {
|
|
if (_this.pickerRef.current) {
|
|
_this.pickerRef.current.blur();
|
|
}
|
|
};
|
|
return _this;
|
|
}
|
|
(0,createClass/* default */.Z)(RangePicker, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return /*#__PURE__*/react.createElement(InnerRangePicker, (0,esm_extends/* default */.Z)({}, this.props, {
|
|
pickerRef: this.pickerRef
|
|
}));
|
|
}
|
|
}]);
|
|
return RangePicker;
|
|
}(react.Component);
|
|
/* harmony default export */ var es_RangePicker = (RangePicker);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/index.js
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var rc_picker_es = (es_Picker);
|
|
// 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/locale-provider/LocaleReceiver.js + 1 modules
|
|
var LocaleReceiver = __webpack_require__(23715);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/statusUtils.js
|
|
var statusUtils = __webpack_require__(9708);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/date-picker/locale/en_US.js + 1 modules
|
|
var en_US = __webpack_require__(21816);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/util.js
|
|
function getPlaceholder(picker, locale, customizePlaceholder) {
|
|
if (customizePlaceholder !== undefined) {
|
|
return customizePlaceholder;
|
|
}
|
|
if (picker === 'year' && locale.lang.yearPlaceholder) {
|
|
return locale.lang.yearPlaceholder;
|
|
}
|
|
if (picker === 'quarter' && locale.lang.quarterPlaceholder) {
|
|
return locale.lang.quarterPlaceholder;
|
|
}
|
|
if (picker === 'month' && locale.lang.monthPlaceholder) {
|
|
return locale.lang.monthPlaceholder;
|
|
}
|
|
if (picker === 'week' && locale.lang.weekPlaceholder) {
|
|
return locale.lang.weekPlaceholder;
|
|
}
|
|
if (picker === 'time' && locale.timePickerLocale.placeholder) {
|
|
return locale.timePickerLocale.placeholder;
|
|
}
|
|
return locale.lang.placeholder;
|
|
}
|
|
function getRangePlaceholder(picker, locale, customizePlaceholder) {
|
|
if (customizePlaceholder !== undefined) {
|
|
return customizePlaceholder;
|
|
}
|
|
if (picker === 'year' && locale.lang.yearPlaceholder) {
|
|
return locale.lang.rangeYearPlaceholder;
|
|
}
|
|
if (picker === 'quarter' && locale.lang.quarterPlaceholder) {
|
|
return locale.lang.rangeQuarterPlaceholder;
|
|
}
|
|
if (picker === 'month' && locale.lang.monthPlaceholder) {
|
|
return locale.lang.rangeMonthPlaceholder;
|
|
}
|
|
if (picker === 'week' && locale.lang.weekPlaceholder) {
|
|
return locale.lang.rangeWeekPlaceholder;
|
|
}
|
|
if (picker === 'time' && locale.timePickerLocale.placeholder) {
|
|
return locale.timePickerLocale.rangePlaceholder;
|
|
}
|
|
return locale.lang.rangePlaceholder;
|
|
}
|
|
function transPlacement2DropdownAlign(direction, placement) {
|
|
var overflow = {
|
|
adjustX: 1,
|
|
adjustY: 1
|
|
};
|
|
switch (placement) {
|
|
case 'bottomLeft':
|
|
{
|
|
return {
|
|
points: ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow: overflow
|
|
};
|
|
}
|
|
case 'bottomRight':
|
|
{
|
|
return {
|
|
points: ['tr', 'br'],
|
|
offset: [0, 4],
|
|
overflow: overflow
|
|
};
|
|
}
|
|
case 'topLeft':
|
|
{
|
|
return {
|
|
points: ['bl', 'tl'],
|
|
offset: [0, -4],
|
|
overflow: overflow
|
|
};
|
|
}
|
|
case 'topRight':
|
|
{
|
|
return {
|
|
points: ['br', 'tr'],
|
|
offset: [0, -4],
|
|
overflow: overflow
|
|
};
|
|
}
|
|
default:
|
|
{
|
|
return {
|
|
points: direction === 'rtl' ? ['tr', 'br'] : ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow: overflow
|
|
};
|
|
}
|
|
}
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/generateRangePicker.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;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function generateRangePicker(generateConfig) {
|
|
var RangePicker = /*#__PURE__*/(0,react.forwardRef)(function (props, ref) {
|
|
var customizePrefixCls = props.prefixCls,
|
|
customGetPopupContainer = props.getPopupContainer,
|
|
className = props.className,
|
|
placement = props.placement,
|
|
customizeSize = props.size,
|
|
customDisabled = props.disabled,
|
|
_props$bordered = props.bordered,
|
|
bordered = _props$bordered === void 0 ? true : _props$bordered,
|
|
placeholder = props.placeholder,
|
|
popupClassName = props.popupClassName,
|
|
dropdownClassName = props.dropdownClassName,
|
|
customStatus = props.status,
|
|
restProps = __rest(props, ["prefixCls", "getPopupContainer", "className", "placement", "size", "disabled", "bordered", "placeholder", "popupClassName", "dropdownClassName", "status"]);
|
|
var innerRef = react.useRef(null);
|
|
var _useContext = (0,react.useContext)(context/* ConfigContext */.E_),
|
|
getPrefixCls = _useContext.getPrefixCls,
|
|
direction = _useContext.direction,
|
|
getPopupContainer = _useContext.getPopupContainer;
|
|
var prefixCls = getPrefixCls('picker', customizePrefixCls);
|
|
var _useCompactItemContex = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction),
|
|
compactSize = _useCompactItemContex.compactSize,
|
|
compactItemClassnames = _useCompactItemContex.compactItemClassnames;
|
|
var format = props.format,
|
|
showTime = props.showTime,
|
|
picker = props.picker;
|
|
var rootPrefixCls = getPrefixCls();
|
|
var additionalOverrideProps = {};
|
|
additionalOverrideProps = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, additionalOverrideProps), showTime ? getTimeProps((0,esm_extends/* default */.Z)({
|
|
format: format,
|
|
picker: picker
|
|
}, showTime)) : {}), picker === 'time' ? getTimeProps((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({
|
|
format: format
|
|
}, props), {
|
|
picker: picker
|
|
})) : {});
|
|
false ? 0 : void 0;
|
|
// ===================== Size =====================
|
|
var size = react.useContext(SizeContext/* default */.Z);
|
|
var mergedSize = compactSize || customizeSize || size;
|
|
// ===================== Disabled =====================
|
|
var disabled = react.useContext(DisabledContext/* default */.Z);
|
|
var mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
// ===================== FormItemInput =====================
|
|
var formItemContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM);
|
|
var hasFeedback = formItemContext.hasFeedback,
|
|
contextStatus = formItemContext.status,
|
|
feedbackIcon = formItemContext.feedbackIcon;
|
|
var suffixNode = /*#__PURE__*/react.createElement(react.Fragment, null, picker === 'time' ? /*#__PURE__*/react.createElement(icons_ClockCircleOutlined, null) : /*#__PURE__*/react.createElement(icons_CalendarOutlined, null), hasFeedback && feedbackIcon);
|
|
(0,react.useImperativeHandle)(ref, function () {
|
|
return {
|
|
focus: function focus() {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.focus();
|
|
},
|
|
blur: function blur() {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.blur();
|
|
}
|
|
};
|
|
});
|
|
return /*#__PURE__*/react.createElement(LocaleReceiver/* default */.Z, {
|
|
componentName: "DatePicker",
|
|
defaultLocale: en_US/* default */.Z
|
|
}, function (contextLocale) {
|
|
var _classNames;
|
|
var locale = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, contextLocale), props.locale);
|
|
return /*#__PURE__*/react.createElement(es_RangePicker, (0,esm_extends/* default */.Z)({
|
|
separator: /*#__PURE__*/react.createElement("span", {
|
|
"aria-label": "to",
|
|
className: "".concat(prefixCls, "-separator")
|
|
}, /*#__PURE__*/react.createElement(icons_SwapRightOutlined, null)),
|
|
disabled: mergedDisabled,
|
|
ref: innerRef,
|
|
dropdownAlign: transPlacement2DropdownAlign(direction, placement),
|
|
placeholder: getRangePlaceholder(picker, locale, placeholder),
|
|
suffixIcon: suffixNode,
|
|
clearIcon: /*#__PURE__*/react.createElement(CloseCircleFilled/* default */.Z, null),
|
|
prevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-prev-icon")
|
|
}),
|
|
nextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-next-icon")
|
|
}),
|
|
superPrevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-super-prev-icon")
|
|
}),
|
|
superNextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-super-next-icon")
|
|
}),
|
|
allowClear: true,
|
|
transitionName: "".concat(rootPrefixCls, "-slide-up")
|
|
}, restProps, additionalOverrideProps, {
|
|
className: classnames_default()((_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-").concat(mergedSize), mergedSize), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-borderless"), !bordered), _classNames), (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus), hasFeedback), compactItemClassnames, className),
|
|
locale: locale.lang,
|
|
prefixCls: prefixCls,
|
|
getPopupContainer: customGetPopupContainer || getPopupContainer,
|
|
generateConfig: generateConfig,
|
|
components: Components,
|
|
direction: direction,
|
|
dropdownClassName: popupClassName || dropdownClassName
|
|
}));
|
|
});
|
|
});
|
|
return RangePicker;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/generateSinglePicker.js
|
|
|
|
|
|
var generateSinglePicker_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;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function generatePicker(generateConfig) {
|
|
function getPicker(picker, displayName) {
|
|
var Picker = /*#__PURE__*/(0,react.forwardRef)(function (props, ref) {
|
|
var customizePrefixCls = props.prefixCls,
|
|
customizeGetPopupContainer = props.getPopupContainer,
|
|
className = props.className,
|
|
customizeSize = props.size,
|
|
_props$bordered = props.bordered,
|
|
bordered = _props$bordered === void 0 ? true : _props$bordered,
|
|
placement = props.placement,
|
|
placeholder = props.placeholder,
|
|
popupClassName = props.popupClassName,
|
|
dropdownClassName = props.dropdownClassName,
|
|
customDisabled = props.disabled,
|
|
customStatus = props.status,
|
|
restProps = generateSinglePicker_rest(props, ["prefixCls", "getPopupContainer", "className", "size", "bordered", "placement", "placeholder", "popupClassName", "dropdownClassName", "disabled", "status"]);
|
|
var _useContext = (0,react.useContext)(context/* ConfigContext */.E_),
|
|
getPrefixCls = _useContext.getPrefixCls,
|
|
direction = _useContext.direction,
|
|
getPopupContainer = _useContext.getPopupContainer;
|
|
var prefixCls = getPrefixCls('picker', customizePrefixCls);
|
|
var _useCompactItemContex = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction),
|
|
compactSize = _useCompactItemContex.compactSize,
|
|
compactItemClassnames = _useCompactItemContex.compactItemClassnames;
|
|
var innerRef = react.useRef(null);
|
|
var format = props.format,
|
|
showTime = props.showTime;
|
|
(0,react.useImperativeHandle)(ref, function () {
|
|
return {
|
|
focus: function focus() {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.focus();
|
|
},
|
|
blur: function blur() {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.blur();
|
|
}
|
|
};
|
|
});
|
|
var additionalProps = {
|
|
showToday: true
|
|
};
|
|
var additionalOverrideProps = {};
|
|
if (picker) {
|
|
additionalOverrideProps.picker = picker;
|
|
}
|
|
var mergedPicker = picker || props.picker;
|
|
additionalOverrideProps = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, additionalOverrideProps), showTime ? getTimeProps((0,esm_extends/* default */.Z)({
|
|
format: format,
|
|
picker: mergedPicker
|
|
}, showTime)) : {}), mergedPicker === 'time' ? getTimeProps((0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({
|
|
format: format
|
|
}, props), {
|
|
picker: mergedPicker
|
|
})) : {});
|
|
var rootPrefixCls = getPrefixCls();
|
|
// =================== Warning =====================
|
|
false ? 0 : void 0;
|
|
false ? 0 : void 0;
|
|
// ===================== Size =====================
|
|
var size = react.useContext(SizeContext/* default */.Z);
|
|
var mergedSize = compactSize || customizeSize || size;
|
|
// ===================== Disabled =====================
|
|
var disabled = react.useContext(DisabledContext/* default */.Z);
|
|
var mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
// ===================== FormItemInput =====================
|
|
var formItemContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM);
|
|
var hasFeedback = formItemContext.hasFeedback,
|
|
contextStatus = formItemContext.status,
|
|
feedbackIcon = formItemContext.feedbackIcon;
|
|
var suffixNode = /*#__PURE__*/react.createElement(react.Fragment, null, mergedPicker === 'time' ? /*#__PURE__*/react.createElement(icons_ClockCircleOutlined, null) : /*#__PURE__*/react.createElement(icons_CalendarOutlined, null), hasFeedback && feedbackIcon);
|
|
return /*#__PURE__*/react.createElement(LocaleReceiver/* default */.Z, {
|
|
componentName: "DatePicker",
|
|
defaultLocale: en_US/* default */.Z
|
|
}, function (contextLocale) {
|
|
var _classNames;
|
|
var locale = (0,esm_extends/* default */.Z)((0,esm_extends/* default */.Z)({}, contextLocale), props.locale);
|
|
return /*#__PURE__*/react.createElement(rc_picker_es, (0,esm_extends/* default */.Z)({
|
|
ref: innerRef,
|
|
placeholder: getPlaceholder(mergedPicker, locale, placeholder),
|
|
suffixIcon: suffixNode,
|
|
dropdownAlign: transPlacement2DropdownAlign(direction, placement),
|
|
clearIcon: /*#__PURE__*/react.createElement(CloseCircleFilled/* default */.Z, null),
|
|
prevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-prev-icon")
|
|
}),
|
|
nextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-next-icon")
|
|
}),
|
|
superPrevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-super-prev-icon")
|
|
}),
|
|
superNextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-super-next-icon")
|
|
}),
|
|
allowClear: true,
|
|
transitionName: "".concat(rootPrefixCls, "-slide-up")
|
|
}, additionalProps, restProps, additionalOverrideProps, {
|
|
locale: locale.lang,
|
|
className: classnames_default()((_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-").concat(mergedSize), mergedSize), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-borderless"), !bordered), _classNames), (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus), hasFeedback), compactItemClassnames, className),
|
|
prefixCls: prefixCls,
|
|
getPopupContainer: customizeGetPopupContainer || getPopupContainer,
|
|
generateConfig: generateConfig,
|
|
components: Components,
|
|
direction: direction,
|
|
disabled: mergedDisabled,
|
|
dropdownClassName: popupClassName || dropdownClassName
|
|
}));
|
|
});
|
|
});
|
|
if (displayName) {
|
|
Picker.displayName = displayName;
|
|
}
|
|
return Picker;
|
|
}
|
|
var DatePicker = getPicker();
|
|
var WeekPicker = getPicker('week', 'WeekPicker');
|
|
var MonthPicker = getPicker('month', 'MonthPicker');
|
|
var YearPicker = getPicker('year', 'YearPicker');
|
|
var TimePicker = getPicker('time', 'TimePicker');
|
|
var QuarterPicker = getPicker('quarter', 'QuarterPicker');
|
|
return {
|
|
DatePicker: DatePicker,
|
|
WeekPicker: WeekPicker,
|
|
MonthPicker: MonthPicker,
|
|
YearPicker: YearPicker,
|
|
TimePicker: TimePicker,
|
|
QuarterPicker: QuarterPicker
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var Components = {
|
|
button: PickerButton,
|
|
rangeItem: PickerTag
|
|
};
|
|
function generatePicker_toArray(list) {
|
|
if (!list) {
|
|
return [];
|
|
}
|
|
return Array.isArray(list) ? list : [list];
|
|
}
|
|
function getTimeProps(props) {
|
|
var format = props.format,
|
|
picker = props.picker,
|
|
showHour = props.showHour,
|
|
showMinute = props.showMinute,
|
|
showSecond = props.showSecond,
|
|
use12Hours = props.use12Hours;
|
|
var firstFormat = generatePicker_toArray(format)[0];
|
|
var showTimeObj = (0,esm_extends/* default */.Z)({}, props);
|
|
if (firstFormat && typeof firstFormat === 'string') {
|
|
if (!firstFormat.includes('s') && showSecond === undefined) {
|
|
showTimeObj.showSecond = false;
|
|
}
|
|
if (!firstFormat.includes('m') && showMinute === undefined) {
|
|
showTimeObj.showMinute = false;
|
|
}
|
|
if (!firstFormat.includes('H') && !firstFormat.includes('h') && showHour === undefined) {
|
|
showTimeObj.showHour = false;
|
|
}
|
|
if ((firstFormat.includes('a') || firstFormat.includes('A')) && use12Hours === undefined) {
|
|
showTimeObj.use12Hours = true;
|
|
}
|
|
}
|
|
if (picker === 'time') {
|
|
return showTimeObj;
|
|
}
|
|
if (typeof firstFormat === 'function') {
|
|
// format of showTime should use default when format is custom format function
|
|
delete showTimeObj.format;
|
|
}
|
|
return {
|
|
showTime: showTimeObj
|
|
};
|
|
}
|
|
var DataPickerPlacements = (0,type/* tuple */.b)('bottomLeft', 'bottomRight', 'topLeft', 'topRight');
|
|
function generatePicker_generatePicker(generateConfig) {
|
|
// =========================== Picker ===========================
|
|
var _generateSinglePicker = generatePicker(generateConfig),
|
|
DatePicker = _generateSinglePicker.DatePicker,
|
|
WeekPicker = _generateSinglePicker.WeekPicker,
|
|
MonthPicker = _generateSinglePicker.MonthPicker,
|
|
YearPicker = _generateSinglePicker.YearPicker,
|
|
TimePicker = _generateSinglePicker.TimePicker,
|
|
QuarterPicker = _generateSinglePicker.QuarterPicker;
|
|
// ======================== Range Picker ========================
|
|
var RangePicker = generateRangePicker(generateConfig);
|
|
var MergedDatePicker = DatePicker;
|
|
MergedDatePicker.WeekPicker = WeekPicker;
|
|
MergedDatePicker.MonthPicker = MonthPicker;
|
|
MergedDatePicker.YearPicker = YearPicker;
|
|
MergedDatePicker.RangePicker = RangePicker;
|
|
MergedDatePicker.TimePicker = TimePicker;
|
|
MergedDatePicker.QuarterPicker = QuarterPicker;
|
|
return MergedDatePicker;
|
|
}
|
|
/* harmony default export */ var date_picker_generatePicker = (generatePicker_generatePicker);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/index.js
|
|
|
|
|
|
var DatePicker = date_picker_generatePicker(generate_moment);
|
|
/* harmony default export */ var date_picker = (DatePicker);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 25763:
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/antd/es/date-picker/style/index.js + 1 modules ***!
|
|
\*********************************************************************/
|
|
/***/ (function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/style/index.less
|
|
// extracted by mini-css-extract-plugin
|
|
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/button/style/index.js + 1 modules
|
|
var style = __webpack_require__(29913);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/tag/style/index.js + 1 modules
|
|
var tag_style = __webpack_require__(71114);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/style/index.js
|
|
|
|
// style dependencies
|
|
|
|
|
|
// deps-lint-skip: form, space
|
|
|
|
/***/ }),
|
|
|
|
/***/ 20550:
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/antd/es/tag/index.js + 1 modules ***!
|
|
\*******************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ tag; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// 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/CloseOutlined.js
|
|
var CloseOutlined = __webpack_require__(62208);
|
|
// 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/omit.js
|
|
var omit = __webpack_require__(98423);
|
|
// 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/_util/colors.js
|
|
var colors = __webpack_require__(98787);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/wave.js + 1 modules
|
|
var wave = __webpack_require__(68349);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/tag/CheckableTag.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 CheckableTag = function CheckableTag(_a) {
|
|
var _classNames;
|
|
var customizePrefixCls = _a.prefixCls,
|
|
className = _a.className,
|
|
checked = _a.checked,
|
|
onChange = _a.onChange,
|
|
onClick = _a.onClick,
|
|
restProps = __rest(_a, ["prefixCls", "className", "checked", "onChange", "onClick"]);
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getPrefixCls = _React$useContext.getPrefixCls;
|
|
var handleClick = function handleClick(e) {
|
|
onChange === null || onChange === void 0 ? void 0 : onChange(!checked);
|
|
onClick === null || onClick === void 0 ? void 0 : onClick(e);
|
|
};
|
|
var prefixCls = getPrefixCls('tag', customizePrefixCls);
|
|
var cls = classnames_default()(prefixCls, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-checkable"), true), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-checkable-checked"), checked), _classNames), className);
|
|
return /*#__PURE__*/react.createElement("span", (0,esm_extends/* default */.Z)({}, restProps, {
|
|
className: cls,
|
|
onClick: handleClick
|
|
}));
|
|
};
|
|
/* harmony default export */ var tag_CheckableTag = (CheckableTag);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/tag/index.js
|
|
|
|
|
|
|
|
var tag_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 PresetColorRegex = new RegExp("^(".concat(colors/* PresetColorTypes.join */.Y.join('|'), ")(-inverse)?$"));
|
|
var PresetStatusColorRegex = new RegExp("^(".concat(colors/* PresetStatusColorTypes.join */.E.join('|'), ")$"));
|
|
var InternalTag = function InternalTag(_a, ref) {
|
|
var _classNames;
|
|
var customizePrefixCls = _a.prefixCls,
|
|
className = _a.className,
|
|
style = _a.style,
|
|
children = _a.children,
|
|
icon = _a.icon,
|
|
color = _a.color,
|
|
onClose = _a.onClose,
|
|
closeIcon = _a.closeIcon,
|
|
_a$closable = _a.closable,
|
|
closable = _a$closable === void 0 ? false : _a$closable,
|
|
props = tag_rest(_a, ["prefixCls", "className", "style", "children", "icon", "color", "onClose", "closeIcon", "closable"]);
|
|
var _React$useContext = react.useContext(context/* ConfigContext */.E_),
|
|
getPrefixCls = _React$useContext.getPrefixCls,
|
|
direction = _React$useContext.direction;
|
|
var _React$useState = react.useState(true),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
visible = _React$useState2[0],
|
|
setVisible = _React$useState2[1];
|
|
// Warning for deprecated usage
|
|
if (false) {}
|
|
react.useEffect(function () {
|
|
if ('visible' in props) {
|
|
setVisible(props.visible);
|
|
}
|
|
}, [props.visible]);
|
|
var isPresetColor = function isPresetColor() {
|
|
if (!color) {
|
|
return false;
|
|
}
|
|
return PresetColorRegex.test(color) || PresetStatusColorRegex.test(color);
|
|
};
|
|
var tagStyle = (0,esm_extends/* default */.Z)({
|
|
backgroundColor: color && !isPresetColor() ? color : undefined
|
|
}, style);
|
|
var presetColor = isPresetColor();
|
|
var prefixCls = getPrefixCls('tag', customizePrefixCls);
|
|
var tagClassName = classnames_default()(prefixCls, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-").concat(color), presetColor), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-has-color"), color && !presetColor), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-hidden"), !visible), (0,defineProperty/* default */.Z)(_classNames, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames), className);
|
|
var handleCloseClick = function handleCloseClick(e) {
|
|
e.stopPropagation();
|
|
onClose === null || onClose === void 0 ? void 0 : onClose(e);
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
if (!('visible' in props)) {
|
|
setVisible(false);
|
|
}
|
|
};
|
|
var renderCloseIcon = function renderCloseIcon() {
|
|
if (closable) {
|
|
return closeIcon ? /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-close-icon"),
|
|
onClick: handleCloseClick
|
|
}, closeIcon) : /*#__PURE__*/react.createElement(CloseOutlined/* default */.Z, {
|
|
className: "".concat(prefixCls, "-close-icon"),
|
|
onClick: handleCloseClick
|
|
});
|
|
}
|
|
return null;
|
|
};
|
|
var isNeedWave = 'onClick' in props || children && children.type === 'a';
|
|
var tagProps = (0,omit/* default */.Z)(props, ['visible']);
|
|
var iconNode = icon || null;
|
|
var kids = iconNode ? /*#__PURE__*/react.createElement(react.Fragment, null, iconNode, /*#__PURE__*/react.createElement("span", null, children)) : children;
|
|
var tagNode = /*#__PURE__*/react.createElement("span", (0,esm_extends/* default */.Z)({}, tagProps, {
|
|
ref: ref,
|
|
className: tagClassName,
|
|
style: tagStyle
|
|
}), kids, renderCloseIcon());
|
|
return isNeedWave ? /*#__PURE__*/react.createElement(wave/* default */.Z, null, tagNode) : tagNode;
|
|
};
|
|
var Tag = /*#__PURE__*/react.forwardRef(InternalTag);
|
|
if (false) {}
|
|
Tag.CheckableTag = tag_CheckableTag;
|
|
/* harmony default export */ var tag = (Tag);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 71114:
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/antd/es/tag/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/tag/style/index.less
|
|
// extracted by mini-css-extract-plugin
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/tag/style/index.js
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
}]); |