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.
11600 lines
408 KiB
11600 lines
408 KiB
(self["webpackChunk"] = self["webpackChunk"] || []).push([[45741],{
|
|
|
|
/***/ 45741:
|
|
/*!*****************************************************************!*\
|
|
!*** ./node_modules/antd/es/date-picker/index.js + 130 modules ***!
|
|
\*****************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ date_picker; }
|
|
});
|
|
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/dayjs.min.js
|
|
var dayjs_min = __webpack_require__(97909);
|
|
var dayjs_min_default = /*#__PURE__*/__webpack_require__.n(dayjs_min);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/warning.js
|
|
/* eslint-disable no-console */
|
|
var warned = {};
|
|
var preWarningFns = [];
|
|
|
|
/**
|
|
* Pre warning enable you to parse content before console.error.
|
|
* Modify to null will prevent warning.
|
|
*/
|
|
var preMessage = function preMessage(fn) {
|
|
preWarningFns.push(fn);
|
|
};
|
|
function warning_warning(valid, message) {
|
|
// Support uglify
|
|
if (false) { var finalMessage; }
|
|
}
|
|
function note(valid, message) {
|
|
// Support uglify
|
|
if (false) { var finalMessage; }
|
|
}
|
|
function resetWarned() {
|
|
warned = {};
|
|
}
|
|
function call(method, valid, message) {
|
|
if (!valid && !warned[message]) {
|
|
method(false, message);
|
|
warned[message] = true;
|
|
}
|
|
}
|
|
function warningOnce(valid, message) {
|
|
call(warning_warning, valid, message);
|
|
}
|
|
function noteOnce(valid, message) {
|
|
call(note, valid, message);
|
|
}
|
|
warningOnce.preMessage = preMessage;
|
|
warningOnce.resetWarned = resetWarned;
|
|
warningOnce.noteOnce = noteOnce;
|
|
/* harmony default export */ var es_warning = (warningOnce);
|
|
/* eslint-enable */
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/plugin/weekday.js
|
|
var weekday = __webpack_require__(33088);
|
|
var weekday_default = /*#__PURE__*/__webpack_require__.n(weekday);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/plugin/localeData.js
|
|
var localeData = __webpack_require__(26850);
|
|
var localeData_default = /*#__PURE__*/__webpack_require__.n(localeData);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/plugin/weekOfYear.js
|
|
var weekOfYear = __webpack_require__(90888);
|
|
var weekOfYear_default = /*#__PURE__*/__webpack_require__.n(weekOfYear);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/plugin/weekYear.js
|
|
var weekYear = __webpack_require__(99873);
|
|
var weekYear_default = /*#__PURE__*/__webpack_require__.n(weekYear);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/plugin/advancedFormat.js
|
|
var advancedFormat = __webpack_require__(86625);
|
|
var advancedFormat_default = /*#__PURE__*/__webpack_require__.n(advancedFormat);
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/dayjs/plugin/customParseFormat.js
|
|
var customParseFormat = __webpack_require__(40618);
|
|
var customParseFormat_default = /*#__PURE__*/__webpack_require__.n(customParseFormat);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/generate/dayjs.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
dayjs_min_default().extend((customParseFormat_default()));
|
|
dayjs_min_default().extend((advancedFormat_default()));
|
|
dayjs_min_default().extend((weekday_default()));
|
|
dayjs_min_default().extend((localeData_default()));
|
|
dayjs_min_default().extend((weekOfYear_default()));
|
|
dayjs_min_default().extend((weekYear_default()));
|
|
dayjs_min_default().extend(function (o, c) {
|
|
// todo support Wo (ISO week)
|
|
var proto = c.prototype;
|
|
var oldFormat = proto.format;
|
|
proto.format = function f(formatStr) {
|
|
var str = (formatStr || '').replace('Wo', 'wo');
|
|
return oldFormat.bind(this)(str);
|
|
};
|
|
});
|
|
var localeMap = {
|
|
// ar_EG:
|
|
// az_AZ:
|
|
// bg_BG:
|
|
bn_BD: 'bn-bd',
|
|
by_BY: 'be',
|
|
// ca_ES:
|
|
// cs_CZ:
|
|
// da_DK:
|
|
// de_DE:
|
|
// el_GR:
|
|
en_GB: 'en-gb',
|
|
en_US: 'en',
|
|
// es_ES:
|
|
// et_EE:
|
|
// fa_IR:
|
|
// fi_FI:
|
|
fr_BE: 'fr',
|
|
// todo: dayjs has no fr_BE locale, use fr at present
|
|
fr_CA: 'fr-ca',
|
|
// fr_FR:
|
|
// ga_IE:
|
|
// gl_ES:
|
|
// he_IL:
|
|
// hi_IN:
|
|
// hr_HR:
|
|
// hu_HU:
|
|
hy_AM: 'hy-am',
|
|
// id_ID:
|
|
// is_IS:
|
|
// it_IT:
|
|
// ja_JP:
|
|
// ka_GE:
|
|
// kk_KZ:
|
|
// km_KH:
|
|
kmr_IQ: 'ku',
|
|
// kn_IN:
|
|
// ko_KR:
|
|
// ku_IQ: // previous ku in antd
|
|
// lt_LT:
|
|
// lv_LV:
|
|
// mk_MK:
|
|
// ml_IN:
|
|
// mn_MN:
|
|
// ms_MY:
|
|
// nb_NO:
|
|
// ne_NP:
|
|
nl_BE: 'nl-be',
|
|
// nl_NL:
|
|
// pl_PL:
|
|
pt_BR: 'pt-br',
|
|
// pt_PT:
|
|
// ro_RO:
|
|
// ru_RU:
|
|
// sk_SK:
|
|
// sl_SI:
|
|
// sr_RS:
|
|
// sv_SE:
|
|
// ta_IN:
|
|
// th_TH:
|
|
// tr_TR:
|
|
// uk_UA:
|
|
// ur_PK:
|
|
// vi_VN:
|
|
zh_CN: 'zh-cn',
|
|
zh_HK: 'zh-hk',
|
|
zh_TW: 'zh-tw'
|
|
};
|
|
var parseLocale = function parseLocale(locale) {
|
|
var mapLocale = localeMap[locale];
|
|
return mapLocale || locale.split('_')[0];
|
|
};
|
|
var parseNoMatchNotice = function parseNoMatchNotice() {
|
|
/* istanbul ignore next */
|
|
noteOnce(false, 'Not match any format. Please help to fire a issue about this.');
|
|
};
|
|
var generateConfig = {
|
|
// get
|
|
getNow: function getNow() {
|
|
return dayjs_min_default()();
|
|
},
|
|
getFixedDate: function getFixedDate(string) {
|
|
return dayjs_min_default()(string, ['YYYY-M-DD', 'YYYY-MM-DD']);
|
|
},
|
|
getEndDate: function getEndDate(date) {
|
|
return date.endOf('month');
|
|
},
|
|
getWeekDay: function getWeekDay(date) {
|
|
var clone = date.locale('en');
|
|
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) {
|
|
return date.add(diff, 'year');
|
|
},
|
|
addMonth: function addMonth(date, diff) {
|
|
return date.add(diff, 'month');
|
|
},
|
|
addDate: function addDate(date, diff) {
|
|
return date.add(diff, 'day');
|
|
},
|
|
setYear: function setYear(date, year) {
|
|
return date.year(year);
|
|
},
|
|
setMonth: function setMonth(date, month) {
|
|
return date.month(month);
|
|
},
|
|
setDate: function setDate(date, num) {
|
|
return date.date(num);
|
|
},
|
|
setHour: function setHour(date, hour) {
|
|
return date.hour(hour);
|
|
},
|
|
setMinute: function setMinute(date, minute) {
|
|
return date.minute(minute);
|
|
},
|
|
setSecond: function setSecond(date, second) {
|
|
return date.second(second);
|
|
},
|
|
// Compare
|
|
isAfter: function isAfter(date1, date2) {
|
|
return date1.isAfter(date2);
|
|
},
|
|
isValidate: function isValidate(date) {
|
|
return date.isValid();
|
|
},
|
|
locale: {
|
|
getWeekFirstDay: function getWeekFirstDay(locale) {
|
|
return dayjs_min_default()().locale(parseLocale(locale)).localeData().firstDayOfWeek();
|
|
},
|
|
getWeekFirstDate: function getWeekFirstDate(locale, date) {
|
|
return date.locale(parseLocale(locale)).weekday(0);
|
|
},
|
|
getWeek: function getWeek(locale, date) {
|
|
return date.locale(parseLocale(locale)).week();
|
|
},
|
|
getShortWeekDays: function getShortWeekDays(locale) {
|
|
return dayjs_min_default()().locale(parseLocale(locale)).localeData().weekdaysMin();
|
|
},
|
|
getShortMonths: function getShortMonths(locale) {
|
|
return dayjs_min_default()().locale(parseLocale(locale)).localeData().monthsShort();
|
|
},
|
|
format: function format(locale, date, _format) {
|
|
return date.locale(parseLocale(locale)).format(_format);
|
|
},
|
|
parse: function parse(locale, text, formats) {
|
|
var localeStr = parseLocale(locale);
|
|
for (var i = 0; i < formats.length; i += 1) {
|
|
var format = formats[i];
|
|
var formatText = text;
|
|
if (format.includes('wo') || format.includes('Wo')) {
|
|
// parse Wo
|
|
var year = formatText.split('-')[0];
|
|
var weekStr = formatText.split('-')[1];
|
|
var firstWeek = dayjs_min_default()(year, 'YYYY').startOf('year').locale(localeStr);
|
|
for (var j = 0; j <= 52; j += 1) {
|
|
var nextWeek = firstWeek.add(j, 'week');
|
|
if (nextWeek.format('Wo') === weekStr) {
|
|
return nextWeek;
|
|
}
|
|
}
|
|
parseNoMatchNotice();
|
|
return null;
|
|
}
|
|
var date = dayjs_min_default()(formatText, format, true).locale(localeStr);
|
|
if (date.isValid()) {
|
|
return date;
|
|
}
|
|
}
|
|
if (text) {
|
|
parseNoMatchNotice();
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
/* harmony default export */ var dayjs = (generateConfig);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/PurePanel.js
|
|
var PurePanel = __webpack_require__(8745);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
var react_namespaceObject = /*#__PURE__*/__webpack_require__.t(react, 2);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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 + 8 modules
|
|
var AntdIcon = __webpack_require__(44327);
|
|
;// 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,esm_extends/* default */.Z)({}, props, {
|
|
ref: ref,
|
|
icon: asn_CalendarOutlined
|
|
}));
|
|
};
|
|
if (false) {}
|
|
/* harmony default export */ var icons_CalendarOutlined = (/*#__PURE__*/react.forwardRef(CalendarOutlined_CalendarOutlined));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/@ant-design/icons-svg/es/asn/ClockCircleOutlined.js
|
|
// 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 */ var asn_ClockCircleOutlined = (ClockCircleOutlined);
|
|
|
|
;// 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_ClockCircleOutlined = function ClockCircleOutlined(props, ref) {
|
|
return /*#__PURE__*/react.createElement(AntdIcon/* default */.Z, (0,esm_extends/* default */.Z)({}, props, {
|
|
ref: ref,
|
|
icon: asn_ClockCircleOutlined
|
|
}));
|
|
};
|
|
if (false) {}
|
|
/* harmony default export */ var icons_ClockCircleOutlined = (/*#__PURE__*/react.forwardRef(ClockCircleOutlined_ClockCircleOutlined));
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/@ant-design/icons/es/icons/CloseCircleFilled.js + 1 modules
|
|
var CloseCircleFilled = __webpack_require__(30186);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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,esm_extends/* default */.Z)({}, props, {
|
|
ref: ref,
|
|
icon: asn_SwapRightOutlined
|
|
}));
|
|
};
|
|
if (false) {}
|
|
/* 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/assertThisInitialized.js
|
|
var assertThisInitialized = __webpack_require__(97326);
|
|
// 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/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/hooks/useEvent.js
|
|
|
|
function useEvent(callback) {
|
|
var fnRef = react.useRef();
|
|
fnRef.current = callback;
|
|
var memoFn = react.useCallback(function () {
|
|
var _fnRef$current;
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
return (_fnRef$current = fnRef.current) === null || _fnRef$current === void 0 ? void 0 : _fnRef$current.call.apply(_fnRef$current, [fnRef].concat(args));
|
|
}, []);
|
|
return memoFn;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/Dom/canUseDom.js
|
|
function canUseDom() {
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
|
|
|
|
|
|
/**
|
|
* Wrap `React.useLayoutEffect` which will not throw warning message in test env
|
|
*/
|
|
var useInternalLayoutEffect = true && canUseDom() ? react.useLayoutEffect : react.useEffect;
|
|
var useLayoutEffect = function useLayoutEffect(callback, deps) {
|
|
var firstMountRef = react.useRef(true);
|
|
useInternalLayoutEffect(function () {
|
|
return callback(firstMountRef.current);
|
|
}, deps);
|
|
|
|
// We tell react that first mount has passed
|
|
useInternalLayoutEffect(function () {
|
|
firstMountRef.current = false;
|
|
return function () {
|
|
firstMountRef.current = true;
|
|
};
|
|
}, []);
|
|
};
|
|
var useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
|
|
useLayoutEffect(function (firstMount) {
|
|
if (!firstMount) {
|
|
return callback();
|
|
}
|
|
}, deps);
|
|
};
|
|
/* harmony default export */ var hooks_useLayoutEffect = (useLayoutEffect);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/hooks/useState.js
|
|
|
|
|
|
/**
|
|
* Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed.
|
|
* We do not make this auto is to avoid real memory leak.
|
|
* Developer should confirm it's safe to ignore themselves.
|
|
*/
|
|
function useSafeState(defaultValue) {
|
|
var destroyRef = react.useRef(false);
|
|
var _React$useState = react.useState(defaultValue),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
value = _React$useState2[0],
|
|
setValue = _React$useState2[1];
|
|
react.useEffect(function () {
|
|
destroyRef.current = false;
|
|
return function () {
|
|
destroyRef.current = true;
|
|
};
|
|
}, []);
|
|
function safeSetState(updater, ignoreDestroy) {
|
|
if (ignoreDestroy && destroyRef.current) {
|
|
return;
|
|
}
|
|
setValue(updater);
|
|
}
|
|
return [value, safeSetState];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/hooks/useMergedState.js
|
|
|
|
|
|
|
|
|
|
/** We only think `undefined` is empty */
|
|
function hasValue(value) {
|
|
return value !== undefined;
|
|
}
|
|
|
|
/**
|
|
* Similar to `useState` but will use props value if provided.
|
|
* Note that internal use rc-util `useState` hook.
|
|
*/
|
|
function useMergedState(defaultStateValue, option) {
|
|
var _ref = option || {},
|
|
defaultValue = _ref.defaultValue,
|
|
value = _ref.value,
|
|
onChange = _ref.onChange,
|
|
postState = _ref.postState;
|
|
|
|
// ======================= Init =======================
|
|
var _useState = useSafeState(function () {
|
|
if (hasValue(value)) {
|
|
return value;
|
|
} else if (hasValue(defaultValue)) {
|
|
return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
|
|
} else {
|
|
return typeof defaultStateValue === 'function' ? defaultStateValue() : defaultStateValue;
|
|
}
|
|
}),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
innerValue = _useState2[0],
|
|
setInnerValue = _useState2[1];
|
|
var mergedValue = value !== undefined ? value : innerValue;
|
|
var postMergedValue = postState ? postState(mergedValue) : mergedValue;
|
|
|
|
// ====================== Change ======================
|
|
var onChangeFn = useEvent(onChange);
|
|
var _useState3 = useSafeState([mergedValue]),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
prevValue = _useState4[0],
|
|
setPrevValue = _useState4[1];
|
|
useLayoutUpdateEffect(function () {
|
|
var prev = prevValue[0];
|
|
if (innerValue !== prev) {
|
|
onChangeFn(innerValue, prev);
|
|
}
|
|
}, [prevValue]);
|
|
|
|
// Sync value back to `undefined` when it from control to un-control
|
|
useLayoutUpdateEffect(function () {
|
|
if (!hasValue(value)) {
|
|
setInnerValue(value);
|
|
}
|
|
}, [value]);
|
|
|
|
// ====================== Update ======================
|
|
var triggerChange = useEvent(function (updater, ignoreDestroy) {
|
|
setInnerValue(updater, ignoreDestroy);
|
|
setPrevValue([mergedValue], ignoreDestroy);
|
|
});
|
|
return [postMergedValue, triggerChange];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/pickAttrs.js
|
|
|
|
var attributes = "accept acceptCharset accessKey action allowFullScreen allowTransparency\n alt async autoComplete autoFocus autoPlay capture cellPadding cellSpacing challenge\n charSet checked classID className colSpan cols content contentEditable contextMenu\n controls coords crossOrigin data dateTime default defer dir disabled download draggable\n encType form formAction formEncType formMethod formNoValidate formTarget frameBorder\n headers height hidden high href hrefLang htmlFor httpEquiv icon id inputMode integrity\n is keyParams keyType kind label lang list loop low manifest marginHeight marginWidth max maxLength media\n mediaGroup method min minLength multiple muted name noValidate nonce open\n optimum pattern placeholder poster preload radioGroup readOnly rel required\n reversed role rowSpan rows sandbox scope scoped scrolling seamless selected\n shape size sizes span spellCheck src srcDoc srcLang srcSet start step style\n summary tabIndex target title type useMap value width wmode wrap";
|
|
var eventsName = "onCopy onCut onPaste onCompositionEnd onCompositionStart onCompositionUpdate onKeyDown\n onKeyPress onKeyUp onFocus onBlur onChange onInput onSubmit onClick onContextMenu onDoubleClick\n onDrag onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop onMouseDown\n onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver onMouseUp onSelect onTouchCancel\n onTouchEnd onTouchMove onTouchStart onScroll onWheel onAbort onCanPlay onCanPlayThrough\n onDurationChange onEmptied onEncrypted onEnded onError onLoadedData onLoadedMetadata\n onLoadStart onPause onPlay onPlaying onProgress onRateChange onSeeked onSeeking onStalled onSuspend onTimeUpdate onVolumeChange onWaiting onLoad onError";
|
|
var propList = "".concat(attributes, " ").concat(eventsName).split(/[\s\n]+/);
|
|
|
|
/* eslint-enable max-len */
|
|
var ariaPrefix = 'aria-';
|
|
var dataPrefix = 'data-';
|
|
function match(key, prefix) {
|
|
return key.indexOf(prefix) === 0;
|
|
}
|
|
/**
|
|
* Picker props from exist props with filter
|
|
* @param props Passed props
|
|
* @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
|
|
*/
|
|
function pickAttrs(props) {
|
|
var ariaOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
var mergedConfig;
|
|
if (ariaOnly === false) {
|
|
mergedConfig = {
|
|
aria: true,
|
|
data: true,
|
|
attr: true
|
|
};
|
|
} else if (ariaOnly === true) {
|
|
mergedConfig = {
|
|
aria: true
|
|
};
|
|
} else {
|
|
mergedConfig = (0,objectSpread2/* default */.Z)({}, ariaOnly);
|
|
}
|
|
var attrs = {};
|
|
Object.keys(props).forEach(function (key) {
|
|
if (
|
|
// Aria
|
|
mergedConfig.aria && (key === 'role' || match(key, ariaPrefix)) ||
|
|
// Data
|
|
mergedConfig.data && match(key, dataPrefix) ||
|
|
// Attr
|
|
mergedConfig.attr && propList.includes(key)) {
|
|
attrs[key] = props[key];
|
|
}
|
|
});
|
|
return attrs;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/hooks/useMemo.js
|
|
|
|
function useMemo_useMemo(getValue, condition, shouldUpdate) {
|
|
var cacheRef = react.useRef({});
|
|
if (!('value' in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
|
|
cacheRef.current.value = getValue();
|
|
cacheRef.current.condition = condition;
|
|
}
|
|
return cacheRef.current.value;
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/isEqual.js
|
|
|
|
|
|
|
|
/**
|
|
* Deeply compares two object literals.
|
|
* @param obj1 object 1
|
|
* @param obj2 object 2
|
|
* @param shallow shallow compare
|
|
* @returns
|
|
*/
|
|
function isEqual(obj1, obj2) {
|
|
var shallow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
// https://github.com/mapbox/mapbox-gl-js/pull/5979/files#diff-fde7145050c47cc3a306856efd5f9c3016e86e859de9afbd02c879be5067e58f
|
|
var refSet = new Set();
|
|
function deepEqual(a, b) {
|
|
var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
|
|
var circular = refSet.has(a);
|
|
es_warning(!circular, 'Warning: There may be circular references');
|
|
if (circular) {
|
|
return false;
|
|
}
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (shallow && level > 1) {
|
|
return false;
|
|
}
|
|
refSet.add(a);
|
|
var newLevel = level + 1;
|
|
if (Array.isArray(a)) {
|
|
if (!Array.isArray(b) || a.length !== b.length) {
|
|
return false;
|
|
}
|
|
for (var i = 0; i < a.length; i++) {
|
|
if (!deepEqual(a[i], b[i], newLevel)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (a && b && (0,esm_typeof/* default */.Z)(a) === 'object' && (0,esm_typeof/* default */.Z)(b) === 'object') {
|
|
var keys = Object.keys(a);
|
|
if (keys.length !== Object.keys(b).length) {
|
|
return false;
|
|
}
|
|
return keys.every(function (key) {
|
|
return deepEqual(a[key], b[key], newLevel);
|
|
});
|
|
}
|
|
// other
|
|
return false;
|
|
}
|
|
return deepEqual(obj1, obj2);
|
|
}
|
|
/* harmony default export */ var es_isEqual = (isEqual);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/panels/DecadePanel/constant.js
|
|
var DECADE_UNIT_DIFF = 10;
|
|
var DECADE_DISTANCE_COUNT = DECADE_UNIT_DIFF * 10;
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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 isSameYear(generateConfig, date1, date2) && generateConfig.locale.getWeek(locale, date1) === generateConfig.locale.getWeek(locale, date2);
|
|
}
|
|
function dateUtil_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/antd/node_modules/rc-picker/es/hooks/useValueTexts.js
|
|
|
|
|
|
|
|
function useValueTexts(value, _ref) {
|
|
var formatList = _ref.formatList,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale;
|
|
return useMemo_useMemo(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, locale], function (prev, next) {
|
|
return (
|
|
// Not Same Date
|
|
!dateUtil_isEqual(generateConfig, prev[0], next[0]) ||
|
|
// Not Same format
|
|
!es_isEqual(prev[1], next[1], true) ||
|
|
// Not Same locale
|
|
!es_isEqual(prev[2], next[2], true)
|
|
);
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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/antd/node_modules/rc-picker/node_modules/rc-util/es/KeyCode.js
|
|
/**
|
|
* @ignore
|
|
* some key-codes definition and utils from closure-library
|
|
* @author yiminghe@gmail.com
|
|
*/
|
|
|
|
var KeyCode = {
|
|
/**
|
|
* MAC_ENTER
|
|
*/
|
|
MAC_ENTER: 3,
|
|
/**
|
|
* BACKSPACE
|
|
*/
|
|
BACKSPACE: 8,
|
|
/**
|
|
* TAB
|
|
*/
|
|
TAB: 9,
|
|
/**
|
|
* NUMLOCK on FF/Safari Mac
|
|
*/
|
|
NUM_CENTER: 12,
|
|
// NUMLOCK on FF/Safari Mac
|
|
/**
|
|
* ENTER
|
|
*/
|
|
ENTER: 13,
|
|
/**
|
|
* SHIFT
|
|
*/
|
|
SHIFT: 16,
|
|
/**
|
|
* CTRL
|
|
*/
|
|
CTRL: 17,
|
|
/**
|
|
* ALT
|
|
*/
|
|
ALT: 18,
|
|
/**
|
|
* PAUSE
|
|
*/
|
|
PAUSE: 19,
|
|
/**
|
|
* CAPS_LOCK
|
|
*/
|
|
CAPS_LOCK: 20,
|
|
/**
|
|
* ESC
|
|
*/
|
|
ESC: 27,
|
|
/**
|
|
* SPACE
|
|
*/
|
|
SPACE: 32,
|
|
/**
|
|
* PAGE_UP
|
|
*/
|
|
PAGE_UP: 33,
|
|
// also NUM_NORTH_EAST
|
|
/**
|
|
* PAGE_DOWN
|
|
*/
|
|
PAGE_DOWN: 34,
|
|
// also NUM_SOUTH_EAST
|
|
/**
|
|
* END
|
|
*/
|
|
END: 35,
|
|
// also NUM_SOUTH_WEST
|
|
/**
|
|
* HOME
|
|
*/
|
|
HOME: 36,
|
|
// also NUM_NORTH_WEST
|
|
/**
|
|
* LEFT
|
|
*/
|
|
LEFT: 37,
|
|
// also NUM_WEST
|
|
/**
|
|
* UP
|
|
*/
|
|
UP: 38,
|
|
// also NUM_NORTH
|
|
/**
|
|
* RIGHT
|
|
*/
|
|
RIGHT: 39,
|
|
// also NUM_EAST
|
|
/**
|
|
* DOWN
|
|
*/
|
|
DOWN: 40,
|
|
// also NUM_SOUTH
|
|
/**
|
|
* PRINT_SCREEN
|
|
*/
|
|
PRINT_SCREEN: 44,
|
|
/**
|
|
* INSERT
|
|
*/
|
|
INSERT: 45,
|
|
// also NUM_INSERT
|
|
/**
|
|
* DELETE
|
|
*/
|
|
DELETE: 46,
|
|
// also NUM_DELETE
|
|
/**
|
|
* ZERO
|
|
*/
|
|
ZERO: 48,
|
|
/**
|
|
* ONE
|
|
*/
|
|
ONE: 49,
|
|
/**
|
|
* TWO
|
|
*/
|
|
TWO: 50,
|
|
/**
|
|
* THREE
|
|
*/
|
|
THREE: 51,
|
|
/**
|
|
* FOUR
|
|
*/
|
|
FOUR: 52,
|
|
/**
|
|
* FIVE
|
|
*/
|
|
FIVE: 53,
|
|
/**
|
|
* SIX
|
|
*/
|
|
SIX: 54,
|
|
/**
|
|
* SEVEN
|
|
*/
|
|
SEVEN: 55,
|
|
/**
|
|
* EIGHT
|
|
*/
|
|
EIGHT: 56,
|
|
/**
|
|
* NINE
|
|
*/
|
|
NINE: 57,
|
|
/**
|
|
* QUESTION_MARK
|
|
*/
|
|
QUESTION_MARK: 63,
|
|
// needs localization
|
|
/**
|
|
* A
|
|
*/
|
|
A: 65,
|
|
/**
|
|
* B
|
|
*/
|
|
B: 66,
|
|
/**
|
|
* C
|
|
*/
|
|
C: 67,
|
|
/**
|
|
* D
|
|
*/
|
|
D: 68,
|
|
/**
|
|
* E
|
|
*/
|
|
E: 69,
|
|
/**
|
|
* F
|
|
*/
|
|
F: 70,
|
|
/**
|
|
* G
|
|
*/
|
|
G: 71,
|
|
/**
|
|
* H
|
|
*/
|
|
H: 72,
|
|
/**
|
|
* I
|
|
*/
|
|
I: 73,
|
|
/**
|
|
* J
|
|
*/
|
|
J: 74,
|
|
/**
|
|
* K
|
|
*/
|
|
K: 75,
|
|
/**
|
|
* L
|
|
*/
|
|
L: 76,
|
|
/**
|
|
* M
|
|
*/
|
|
M: 77,
|
|
/**
|
|
* N
|
|
*/
|
|
N: 78,
|
|
/**
|
|
* O
|
|
*/
|
|
O: 79,
|
|
/**
|
|
* P
|
|
*/
|
|
P: 80,
|
|
/**
|
|
* Q
|
|
*/
|
|
Q: 81,
|
|
/**
|
|
* R
|
|
*/
|
|
R: 82,
|
|
/**
|
|
* S
|
|
*/
|
|
S: 83,
|
|
/**
|
|
* T
|
|
*/
|
|
T: 84,
|
|
/**
|
|
* U
|
|
*/
|
|
U: 85,
|
|
/**
|
|
* V
|
|
*/
|
|
V: 86,
|
|
/**
|
|
* W
|
|
*/
|
|
W: 87,
|
|
/**
|
|
* X
|
|
*/
|
|
X: 88,
|
|
/**
|
|
* Y
|
|
*/
|
|
Y: 89,
|
|
/**
|
|
* Z
|
|
*/
|
|
Z: 90,
|
|
/**
|
|
* META
|
|
*/
|
|
META: 91,
|
|
// WIN_KEY_LEFT
|
|
/**
|
|
* WIN_KEY_RIGHT
|
|
*/
|
|
WIN_KEY_RIGHT: 92,
|
|
/**
|
|
* CONTEXT_MENU
|
|
*/
|
|
CONTEXT_MENU: 93,
|
|
/**
|
|
* NUM_ZERO
|
|
*/
|
|
NUM_ZERO: 96,
|
|
/**
|
|
* NUM_ONE
|
|
*/
|
|
NUM_ONE: 97,
|
|
/**
|
|
* NUM_TWO
|
|
*/
|
|
NUM_TWO: 98,
|
|
/**
|
|
* NUM_THREE
|
|
*/
|
|
NUM_THREE: 99,
|
|
/**
|
|
* NUM_FOUR
|
|
*/
|
|
NUM_FOUR: 100,
|
|
/**
|
|
* NUM_FIVE
|
|
*/
|
|
NUM_FIVE: 101,
|
|
/**
|
|
* NUM_SIX
|
|
*/
|
|
NUM_SIX: 102,
|
|
/**
|
|
* NUM_SEVEN
|
|
*/
|
|
NUM_SEVEN: 103,
|
|
/**
|
|
* NUM_EIGHT
|
|
*/
|
|
NUM_EIGHT: 104,
|
|
/**
|
|
* NUM_NINE
|
|
*/
|
|
NUM_NINE: 105,
|
|
/**
|
|
* NUM_MULTIPLY
|
|
*/
|
|
NUM_MULTIPLY: 106,
|
|
/**
|
|
* NUM_PLUS
|
|
*/
|
|
NUM_PLUS: 107,
|
|
/**
|
|
* NUM_MINUS
|
|
*/
|
|
NUM_MINUS: 109,
|
|
/**
|
|
* NUM_PERIOD
|
|
*/
|
|
NUM_PERIOD: 110,
|
|
/**
|
|
* NUM_DIVISION
|
|
*/
|
|
NUM_DIVISION: 111,
|
|
/**
|
|
* F1
|
|
*/
|
|
F1: 112,
|
|
/**
|
|
* F2
|
|
*/
|
|
F2: 113,
|
|
/**
|
|
* F3
|
|
*/
|
|
F3: 114,
|
|
/**
|
|
* F4
|
|
*/
|
|
F4: 115,
|
|
/**
|
|
* F5
|
|
*/
|
|
F5: 116,
|
|
/**
|
|
* F6
|
|
*/
|
|
F6: 117,
|
|
/**
|
|
* F7
|
|
*/
|
|
F7: 118,
|
|
/**
|
|
* F8
|
|
*/
|
|
F8: 119,
|
|
/**
|
|
* F9
|
|
*/
|
|
F9: 120,
|
|
/**
|
|
* F10
|
|
*/
|
|
F10: 121,
|
|
/**
|
|
* F11
|
|
*/
|
|
F11: 122,
|
|
/**
|
|
* F12
|
|
*/
|
|
F12: 123,
|
|
/**
|
|
* NUMLOCK
|
|
*/
|
|
NUMLOCK: 144,
|
|
/**
|
|
* SEMICOLON
|
|
*/
|
|
SEMICOLON: 186,
|
|
// needs localization
|
|
/**
|
|
* DASH
|
|
*/
|
|
DASH: 189,
|
|
// needs localization
|
|
/**
|
|
* EQUALS
|
|
*/
|
|
EQUALS: 187,
|
|
// needs localization
|
|
/**
|
|
* COMMA
|
|
*/
|
|
COMMA: 188,
|
|
// needs localization
|
|
/**
|
|
* PERIOD
|
|
*/
|
|
PERIOD: 190,
|
|
// needs localization
|
|
/**
|
|
* SLASH
|
|
*/
|
|
SLASH: 191,
|
|
// needs localization
|
|
/**
|
|
* APOSTROPHE
|
|
*/
|
|
APOSTROPHE: 192,
|
|
// needs localization
|
|
/**
|
|
* SINGLE_QUOTE
|
|
*/
|
|
SINGLE_QUOTE: 222,
|
|
// needs localization
|
|
/**
|
|
* OPEN_SQUARE_BRACKET
|
|
*/
|
|
OPEN_SQUARE_BRACKET: 219,
|
|
// needs localization
|
|
/**
|
|
* BACKSLASH
|
|
*/
|
|
BACKSLASH: 220,
|
|
// needs localization
|
|
/**
|
|
* CLOSE_SQUARE_BRACKET
|
|
*/
|
|
CLOSE_SQUARE_BRACKET: 221,
|
|
// needs localization
|
|
/**
|
|
* WIN_KEY
|
|
*/
|
|
WIN_KEY: 224,
|
|
/**
|
|
* MAC_FF_META
|
|
*/
|
|
MAC_FF_META: 224,
|
|
// Firefox (Gecko) fires this for the meta key instead of 91
|
|
/**
|
|
* WIN_IME
|
|
*/
|
|
WIN_IME: 229,
|
|
// ======================== Function ========================
|
|
/**
|
|
* whether text and modified key is entered at the same time.
|
|
*/
|
|
isTextModifyingKeyEvent: function isTextModifyingKeyEvent(e) {
|
|
var keyCode = e.keyCode;
|
|
if (e.altKey && !e.ctrlKey || e.metaKey ||
|
|
// Function keys don't generate text
|
|
keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) {
|
|
return false;
|
|
}
|
|
|
|
// The following keys are quite harmless, even in combination with
|
|
// CTRL, ALT or SHIFT.
|
|
switch (keyCode) {
|
|
case KeyCode.ALT:
|
|
case KeyCode.CAPS_LOCK:
|
|
case KeyCode.CONTEXT_MENU:
|
|
case KeyCode.CTRL:
|
|
case KeyCode.DOWN:
|
|
case KeyCode.END:
|
|
case KeyCode.ESC:
|
|
case KeyCode.HOME:
|
|
case KeyCode.INSERT:
|
|
case KeyCode.LEFT:
|
|
case KeyCode.MAC_FF_META:
|
|
case KeyCode.META:
|
|
case KeyCode.NUMLOCK:
|
|
case KeyCode.NUM_CENTER:
|
|
case KeyCode.PAGE_DOWN:
|
|
case KeyCode.PAGE_UP:
|
|
case KeyCode.PAUSE:
|
|
case KeyCode.PRINT_SCREEN:
|
|
case KeyCode.RIGHT:
|
|
case KeyCode.SHIFT:
|
|
case KeyCode.UP:
|
|
case KeyCode.WIN_KEY:
|
|
case KeyCode.WIN_KEY_RIGHT:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
},
|
|
/**
|
|
* whether character is entered.
|
|
*/
|
|
isCharacterKey: function isCharacterKey(keyCode) {
|
|
if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) {
|
|
return true;
|
|
}
|
|
if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) {
|
|
return true;
|
|
}
|
|
if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) {
|
|
return true;
|
|
}
|
|
|
|
// Safari sends zero key code for non-latin characters.
|
|
if (window.navigator.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) {
|
|
return true;
|
|
}
|
|
switch (keyCode) {
|
|
case KeyCode.SPACE:
|
|
case KeyCode.QUESTION_MARK:
|
|
case KeyCode.NUM_PLUS:
|
|
case KeyCode.NUM_MINUS:
|
|
case KeyCode.NUM_PERIOD:
|
|
case KeyCode.NUM_DIVISION:
|
|
case KeyCode.SEMICOLON:
|
|
case KeyCode.DASH:
|
|
case KeyCode.EQUALS:
|
|
case KeyCode.COMMA:
|
|
case KeyCode.PERIOD:
|
|
case KeyCode.SLASH:
|
|
case KeyCode.APOSTROPHE:
|
|
case KeyCode.SINGLE_QUOTE:
|
|
case KeyCode.OPEN_SQUARE_BRACKET:
|
|
case KeyCode.BACKSLASH:
|
|
case KeyCode.CLOSE_SQUARE_BRACKET:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
/* harmony default export */ var es_KeyCode = (KeyCode);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/raf.js
|
|
var raf = function raf(callback) {
|
|
return +setTimeout(callback, 16);
|
|
};
|
|
var caf = function caf(num) {
|
|
return clearTimeout(num);
|
|
};
|
|
if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
|
|
raf = function raf(callback) {
|
|
return window.requestAnimationFrame(callback);
|
|
};
|
|
caf = function caf(handle) {
|
|
return window.cancelAnimationFrame(handle);
|
|
};
|
|
}
|
|
var rafUUID = 0;
|
|
var rafIds = new Map();
|
|
function cleanup(id) {
|
|
rafIds.delete(id);
|
|
}
|
|
var wrapperRaf = function wrapperRaf(callback) {
|
|
var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
rafUUID += 1;
|
|
var id = rafUUID;
|
|
function callRef(leftTimes) {
|
|
if (leftTimes === 0) {
|
|
// Clean up
|
|
cleanup(id);
|
|
|
|
// Trigger
|
|
callback();
|
|
} else {
|
|
// Next raf
|
|
var realId = raf(function () {
|
|
callRef(leftTimes - 1);
|
|
});
|
|
|
|
// Bind real raf id
|
|
rafIds.set(id, realId);
|
|
}
|
|
}
|
|
callRef(times);
|
|
return id;
|
|
};
|
|
wrapperRaf.cancel = function (id) {
|
|
var realId = rafIds.get(id);
|
|
cleanup(realId);
|
|
return caf(realId);
|
|
};
|
|
/* harmony default export */ var es_raf = (wrapperRaf);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(74902);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/Dom/isVisible.js
|
|
/* harmony default export */ var isVisible = (function (element) {
|
|
if (!element) {
|
|
return false;
|
|
}
|
|
if (element instanceof Element) {
|
|
if (element.offsetParent) {
|
|
return true;
|
|
}
|
|
if (element.getBBox) {
|
|
var _getBBox = element.getBBox(),
|
|
width = _getBBox.width,
|
|
height = _getBBox.height;
|
|
if (width || height) {
|
|
return true;
|
|
}
|
|
}
|
|
if (element.getBoundingClientRect) {
|
|
var _element$getBoundingC = element.getBoundingClientRect(),
|
|
_width = _element$getBoundingC.width,
|
|
_height = _element$getBoundingC.height;
|
|
if (_width || _height) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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 (isVisible(element)) {
|
|
callback();
|
|
} else {
|
|
id = es_raf(function () {
|
|
tryOrNextFrame();
|
|
});
|
|
}
|
|
}
|
|
tryOrNextFrame();
|
|
return function () {
|
|
es_raf.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);
|
|
}
|
|
}));
|
|
}
|
|
/* eslint-enable */
|
|
|
|
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 es_KeyCode.LEFT:
|
|
if (ctrlKey || metaKey) {
|
|
if (onCtrlLeftRight) {
|
|
onCtrlLeftRight(-1);
|
|
return true;
|
|
}
|
|
} else if (onLeftRight) {
|
|
onLeftRight(-1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case es_KeyCode.RIGHT:
|
|
if (ctrlKey || metaKey) {
|
|
if (onCtrlLeftRight) {
|
|
onCtrlLeftRight(1);
|
|
return true;
|
|
}
|
|
} else if (onLeftRight) {
|
|
onLeftRight(1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case es_KeyCode.UP:
|
|
if (onUpDown) {
|
|
onUpDown(-1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case es_KeyCode.DOWN:
|
|
if (onUpDown) {
|
|
onUpDown(1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case es_KeyCode.PAGE_UP:
|
|
if (onPageUpDown) {
|
|
onPageUpDown(-1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case es_KeyCode.PAGE_DOWN:
|
|
if (onPageUpDown) {
|
|
onPageUpDown(1);
|
|
return true;
|
|
}
|
|
/* istanbul ignore next */
|
|
break;
|
|
case es_KeyCode.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;
|
|
}
|
|
|
|
// ===================== Window =====================
|
|
|
|
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/antd/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,
|
|
changeOnBlur = _ref.changeOnBlur;
|
|
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];
|
|
|
|
/**
|
|
* 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 es_KeyCode.ENTER:
|
|
{
|
|
if (!open) {
|
|
triggerOpen(true);
|
|
} else if (onSubmit() !== false) {
|
|
setTyping(true);
|
|
}
|
|
e.preventDefault();
|
|
return;
|
|
}
|
|
case es_KeyCode.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 es_KeyCode.ESC:
|
|
{
|
|
setTyping(true);
|
|
onCancel();
|
|
return;
|
|
}
|
|
}
|
|
if (!open && ![es_KeyCode.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 (_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);
|
|
_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);
|
|
var clickedOutside = isClickOutside(target);
|
|
if (open) {
|
|
if (!clickedOutside) {
|
|
preventBlurRef.current = true;
|
|
|
|
// Always set back in case `onBlur` prevented by user
|
|
es_raf(function () {
|
|
preventBlurRef.current = false;
|
|
});
|
|
} else if (!changeOnBlur && (!focused || clickedOutside)) {
|
|
triggerOpen(false);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
return [inputProps, {
|
|
focused: focused,
|
|
typing: typing
|
|
}];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/hooks/usePresets.js
|
|
|
|
|
|
|
|
function usePresets(presets, legacyRanges) {
|
|
return react.useMemo(function () {
|
|
if (presets) {
|
|
return presets;
|
|
}
|
|
if (legacyRanges) {
|
|
es_warning(false, '`ranges` is deprecated. Please use `presets` instead.');
|
|
return Object.entries(legacyRanges).map(function (_ref) {
|
|
var _ref2 = (0,slicedToArray/* default */.Z)(_ref, 2),
|
|
label = _ref2[0],
|
|
value = _ref2[1];
|
|
return {
|
|
label: label,
|
|
value: value
|
|
};
|
|
});
|
|
}
|
|
return [];
|
|
}, [presets, legacyRanges]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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]);
|
|
}
|
|
hooks_useLayoutEffect(function () {
|
|
if (valueTexts.every(function (valText) {
|
|
return valText !== text;
|
|
})) {
|
|
resetText();
|
|
}
|
|
}, [valueTexts.join('||')]);
|
|
return [text, triggerTextChange, resetText];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/PanelContext.js
|
|
|
|
var PanelContext = /*#__PURE__*/react.createContext({});
|
|
/* harmony default export */ var es_PanelContext = (PanelContext);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/hooks/useCellRender.js
|
|
|
|
function useCellRender(_ref) {
|
|
var cellRender = _ref.cellRender,
|
|
monthCellRender = _ref.monthCellRender,
|
|
dateRender = _ref.dateRender;
|
|
var mergedCellRender = react.useMemo(function () {
|
|
if (cellRender) return cellRender;
|
|
if (!monthCellRender && !dateRender) return undefined;
|
|
return function (current, info) {
|
|
var date = current;
|
|
if (dateRender && info.type === 'date') {
|
|
return dateRender(date, info.today);
|
|
}
|
|
if (monthCellRender && info.type === 'month') {
|
|
return monthCellRender(date, info.locale);
|
|
}
|
|
return info.originNode;
|
|
};
|
|
}, [cellRender, monthCellRender, dateRender]);
|
|
return mergedCellRender;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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 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;
|
|
}
|
|
function executeValue(value) {
|
|
return typeof value === 'function' ? value() : value;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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/antd/node_modules/rc-picker/es/RangeContext.js
|
|
|
|
var RangeContext = /*#__PURE__*/react.createContext({});
|
|
/* harmony default export */ var es_RangeContext = (RangeContext);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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/antd/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() {
|
|
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);
|
|
var inner = /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(cellPrefixCls, "-inner")
|
|
}, getCellText(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, inner) : inner));
|
|
};
|
|
for (var j = 0; j < colNum; j += 1) {
|
|
_loop();
|
|
}
|
|
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/antd/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,
|
|
cellRender = props.cellRender,
|
|
isSameCell = props.isSameCell;
|
|
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: isSameCell || function (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 = cellRender ? function (date, wrapperNode) {
|
|
return cellRender(date, {
|
|
originNode: wrapperNode,
|
|
today: today,
|
|
type: 'date',
|
|
locale: locale
|
|
});
|
|
} : 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/antd/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/antd/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/antd/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/antd/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);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/hooks/useTimeSelection.js
|
|
|
|
function useTimeSelection(_ref) {
|
|
var value = _ref.value,
|
|
generateConfig = _ref.generateConfig,
|
|
disabledMinutes = _ref.disabledMinutes,
|
|
disabledSeconds = _ref.disabledSeconds,
|
|
minutes = _ref.minutes,
|
|
seconds = _ref.seconds,
|
|
use12Hours = _ref.use12Hours;
|
|
var setTime = function setTime(isNewPM, newHour, newMinute, newSecond) {
|
|
var now = generateConfig.getNow();
|
|
var newDate = value || now;
|
|
var mergedHour = newHour < 0 ? generateConfig.getHour(now) : newHour;
|
|
var mergedMinute = newMinute < 0 ? generateConfig.getMinute(now) : newMinute;
|
|
var mergedSecond = newSecond < 0 ? generateConfig.getSecond(now) : newSecond;
|
|
var newDisabledMinutes = disabledMinutes && disabledMinutes(mergedHour);
|
|
if (newDisabledMinutes !== null && newDisabledMinutes !== void 0 && newDisabledMinutes.includes(mergedMinute)) {
|
|
// find the first available minute in minutes
|
|
var availableMinute = minutes.find(function (i) {
|
|
return !newDisabledMinutes.includes(i.value);
|
|
});
|
|
if (availableMinute) {
|
|
mergedMinute = availableMinute.value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
var newDisabledSeconds = disabledSeconds && disabledSeconds(mergedHour, mergedMinute);
|
|
if (newDisabledSeconds !== null && newDisabledSeconds !== void 0 && newDisabledSeconds.includes(mergedSecond)) {
|
|
// find the first available second in seconds
|
|
var availableSecond = seconds.find(function (i) {
|
|
return !newDisabledSeconds.includes(i.value);
|
|
});
|
|
if (availableSecond) {
|
|
mergedSecond = availableSecond.value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
newDate = timeUtil_setTime(generateConfig, newDate, !use12Hours || !isNewPM ? mergedHour : mergedHour + 12, mergedMinute, mergedSecond);
|
|
return newDate;
|
|
};
|
|
return setTime;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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,
|
|
info = props.info,
|
|
type = props.type;
|
|
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);
|
|
}
|
|
}, info.cellRender ? info.cellRender(unit.value, {
|
|
today: info.today,
|
|
locale: info.locale,
|
|
originNode: /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(cellPrefixCls, "-inner")
|
|
}, unit.label),
|
|
type: 'time',
|
|
subType: type
|
|
}) : /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(cellPrefixCls, "-inner")
|
|
}, unit.label));
|
|
}));
|
|
}
|
|
/* harmony default export */ var TimePanel_TimeUnitColumn = (TimeUnitColumn);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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 = [];
|
|
var integerStep = step >= 1 ? step | 0 : 1;
|
|
for (var i = start; i <= end; i += integerStep) {
|
|
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,
|
|
cellRender = props.cellRender,
|
|
locale = props.locale;
|
|
|
|
// 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];
|
|
|
|
// ========================= Unit =========================
|
|
var rawHours = generateUnits(0, 23, hourStep, mergedDisabledHours && mergedDisabledHours());
|
|
var memorizedRawHours = useMemo_useMemo(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));
|
|
|
|
// Set Time
|
|
var setTime = useTimeSelection({
|
|
value: value,
|
|
generateConfig: generateConfig,
|
|
disabledMinutes: mergedDisabledMinutes,
|
|
disabledSeconds: mergedDisabledSeconds,
|
|
minutes: minutes,
|
|
seconds: seconds,
|
|
use12Hours: use12Hours
|
|
});
|
|
|
|
// ====================== 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",
|
|
type: "hour",
|
|
info: {
|
|
today: now,
|
|
locale: locale,
|
|
cellRender: cellRender
|
|
}
|
|
}), hour, hours, function (num) {
|
|
onSelect(setTime(isPM, num, minute, second), 'mouse');
|
|
});
|
|
|
|
// Minute
|
|
addColumnNode(showMinute, /*#__PURE__*/react.createElement(TimePanel_TimeUnitColumn, {
|
|
key: "minute",
|
|
type: "minute",
|
|
info: {
|
|
today: now,
|
|
locale: locale,
|
|
cellRender: cellRender
|
|
}
|
|
}), minute, minutes, function (num) {
|
|
onSelect(setTime(isPM, hour, num, second), 'mouse');
|
|
});
|
|
|
|
// Second
|
|
addColumnNode(showSecond, /*#__PURE__*/react.createElement(TimePanel_TimeUnitColumn, {
|
|
key: "second",
|
|
type: "second",
|
|
info: {
|
|
today: now,
|
|
locale: locale,
|
|
cellRender: cellRender
|
|
}
|
|
}), 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: "meridiem",
|
|
type: "meridiem",
|
|
info: {
|
|
today: now,
|
|
locale: locale,
|
|
cellRender: cellRender
|
|
}
|
|
}), 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/antd/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/antd/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,
|
|
cellRender = props.cellRender;
|
|
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 === es_KeyCode.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 ([es_KeyCode.LEFT, es_KeyCode.RIGHT, es_KeyCode.UP, es_KeyCode.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, {
|
|
cellRender: cellRender,
|
|
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, {
|
|
cellRender: cellRender ? function (current, info) {
|
|
return cellRender(current, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, info), {}, {
|
|
type: 'time'
|
|
}));
|
|
} : undefined,
|
|
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/antd/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/antd/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,
|
|
cellRender = props.cellRender,
|
|
locale = props.locale;
|
|
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;
|
|
};
|
|
var getCellNode = cellRender ? function (date, wrapperNode) {
|
|
return cellRender(date, {
|
|
originNode: wrapperNode,
|
|
today: generateConfig.getNow(),
|
|
type: 'decade',
|
|
locale: locale
|
|
});
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: DECADE_ROW_COUNT,
|
|
colNum: DECADE_COL_COUNT,
|
|
baseDate: baseDecadeYear,
|
|
getCellNode: getCellNode,
|
|
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);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/panels/DecadePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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/antd/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/antd/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,
|
|
cellRender = props.cellRender;
|
|
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 = cellRender ? function (date, wrapperNode) {
|
|
return cellRender(date, {
|
|
originNode: wrapperNode,
|
|
locale: locale,
|
|
today: generateConfig.getNow(),
|
|
type: 'month'
|
|
});
|
|
} : 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/antd/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/antd/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/antd/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,
|
|
cellRender = props.cellRender;
|
|
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);
|
|
var getCellNode = cellRender ? function (date, wrapperNode) {
|
|
return cellRender(date, {
|
|
originNode: wrapperNode,
|
|
locale: locale,
|
|
today: generateConfig.getNow(),
|
|
type: 'quarter'
|
|
});
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: QUARTER_ROW_COUNT,
|
|
colNum: QUARTER_COL_COUNT,
|
|
baseDate: baseQuarter,
|
|
getCellNode: getCellNode,
|
|
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/antd/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/antd/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,
|
|
disabledDate = props.disabledDate,
|
|
onSelect = props.onSelect;
|
|
var _React$useContext = react.useContext(es_RangeContext),
|
|
rangedValue = _React$useContext.rangedValue,
|
|
hoverRangedValue = _React$useContext.hoverRangedValue;
|
|
var _React$useContext2 = react.useContext(es_PanelContext),
|
|
onDateMouseEnter = _React$useContext2.onDateMouseEnter,
|
|
onDateMouseLeave = _React$useContext2.onDateMouseLeave;
|
|
var rangeStart = (hoverRangedValue === null || hoverRangedValue === void 0 ? void 0 : hoverRangedValue[0]) || (rangedValue === null || rangedValue === void 0 ? void 0 : rangedValue[0]);
|
|
var rangeEnd = (hoverRangedValue === null || hoverRangedValue === void 0 ? void 0 : hoverRangedValue[1]) || (rangedValue === null || rangedValue === void 0 ? void 0 : rangedValue[1]);
|
|
|
|
// Render additional column
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
var prefixColumn = function prefixColumn(date) {
|
|
// >>> Additional check for disabled
|
|
var disabled = getCellDateDisabled({
|
|
cellDate: date,
|
|
mode: 'week',
|
|
disabledDate: disabledDate,
|
|
generateConfig: generateConfig
|
|
});
|
|
return /*#__PURE__*/react.createElement("td", {
|
|
key: "week",
|
|
className: classnames_default()(cellPrefixCls, "".concat(cellPrefixCls, "-week"))
|
|
// Operation: Same as code in PanelBody
|
|
,
|
|
onClick: function onClick() {
|
|
if (!disabled) {
|
|
onSelect(date, 'mouse');
|
|
}
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
if (!disabled && onDateMouseEnter) {
|
|
onDateMouseEnter(date);
|
|
}
|
|
},
|
|
onMouseLeave: function onMouseLeave() {
|
|
if (!disabled && onDateMouseLeave) {
|
|
onDateMouseLeave(date);
|
|
}
|
|
}
|
|
}, /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(cellPrefixCls, "-inner")
|
|
}, generateConfig.locale.getWeek(locale.locale, date)));
|
|
};
|
|
|
|
// Add row className
|
|
var rowPrefixCls = "".concat(prefixCls, "-week-panel-row");
|
|
var rowClassName = function rowClassName(date) {
|
|
var _classNames;
|
|
var isRangeStart = isSameWeek(generateConfig, locale.locale, rangeStart, date);
|
|
var isRangeEnd = isSameWeek(generateConfig, locale.locale, rangeEnd, date);
|
|
return classnames_default()(rowPrefixCls, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(rowPrefixCls, "-selected"), !rangedValue && isSameWeek(generateConfig, locale.locale, value, date)), (0,defineProperty/* default */.Z)(_classNames, "".concat(rowPrefixCls, "-range-start"), isRangeStart), (0,defineProperty/* default */.Z)(_classNames, "".concat(rowPrefixCls, "-range-end"), isRangeEnd), (0,defineProperty/* default */.Z)(_classNames, "".concat(rowPrefixCls, "-range-hover"), !isRangeStart && !isRangeEnd && isInRange(generateConfig, rangeStart, rangeEnd, date)), _classNames));
|
|
};
|
|
return /*#__PURE__*/react.createElement(panels_DatePanel, (0,esm_extends/* default */.Z)({}, props, {
|
|
panelName: "week",
|
|
prefixColumn: prefixColumn,
|
|
rowClassName: rowClassName,
|
|
keyboardConfig: {
|
|
onLeftRight: null
|
|
}
|
|
// No need check cell level
|
|
,
|
|
isSameCell: function isSameCell() {
|
|
return false;
|
|
}
|
|
}));
|
|
}
|
|
/* harmony default export */ var panels_WeekPanel = (WeekPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/panels/YearPanel/constant.js
|
|
var YEAR_DECADE_COUNT = 10;
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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/antd/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,
|
|
cellRender = props.cellRender;
|
|
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 today = generateConfig.getNow();
|
|
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);
|
|
}
|
|
});
|
|
var getCellNode = cellRender ? function (date, wrapperNode) {
|
|
return cellRender(date, {
|
|
originNode: wrapperNode,
|
|
today: today,
|
|
type: 'year',
|
|
locale: locale
|
|
});
|
|
} : undefined;
|
|
return /*#__PURE__*/react.createElement(PanelBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
rowNum: YEAR_ROW_COUNT,
|
|
colNum: YEAR_COL_COUNT,
|
|
baseDate: baseYear,
|
|
getCellNode: getCellNode,
|
|
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/antd/node_modules/rc-picker/es/panels/YearPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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/antd/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/antd/node_modules/rc-picker/es/utils/getRanges.js
|
|
|
|
function getRanges(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
_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 (needConfirmButton) {
|
|
var Button = components.button || 'button';
|
|
if (onNow && 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/antd/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`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// TMP type to fit for ts 3.9.2
|
|
|
|
// Calendar picker type
|
|
var CALENDAR_PANEL_MODE = ['date', 'month'];
|
|
function PickerPanel(props) {
|
|
var _classNames;
|
|
var _ref = props,
|
|
_ref$prefixCls = _ref.prefixCls,
|
|
prefixCls = _ref$prefixCls === void 0 ? 'rc-picker' : _ref$prefixCls,
|
|
className = _ref.className,
|
|
style = _ref.style,
|
|
locale = _ref.locale,
|
|
generateConfig = _ref.generateConfig,
|
|
value = _ref.value,
|
|
defaultValue = _ref.defaultValue,
|
|
pickerValue = _ref.pickerValue,
|
|
defaultPickerValue = _ref.defaultPickerValue,
|
|
disabledDate = _ref.disabledDate,
|
|
mode = _ref.mode,
|
|
_ref$picker = _ref.picker,
|
|
picker = _ref$picker === void 0 ? 'date' : _ref$picker,
|
|
_ref$tabIndex = _ref.tabIndex,
|
|
tabIndex = _ref$tabIndex === void 0 ? 0 : _ref$tabIndex,
|
|
showNow = _ref.showNow,
|
|
showTime = _ref.showTime,
|
|
showToday = _ref.showToday,
|
|
renderExtraFooter = _ref.renderExtraFooter,
|
|
hideHeader = _ref.hideHeader,
|
|
onSelect = _ref.onSelect,
|
|
onChange = _ref.onChange,
|
|
onPanelChange = _ref.onPanelChange,
|
|
onMouseDown = _ref.onMouseDown,
|
|
onPickerValueChange = _ref.onPickerValueChange,
|
|
_onOk = _ref.onOk,
|
|
components = _ref.components,
|
|
direction = _ref.direction,
|
|
_ref$hourStep = _ref.hourStep,
|
|
hourStep = _ref$hourStep === void 0 ? 1 : _ref$hourStep,
|
|
_ref$minuteStep = _ref.minuteStep,
|
|
minuteStep = _ref$minuteStep === void 0 ? 1 : _ref$minuteStep,
|
|
_ref$secondStep = _ref.secondStep,
|
|
secondStep = _ref$secondStep === void 0 ? 1 : _ref$secondStep,
|
|
dateRender = _ref.dateRender,
|
|
monthCellRender = _ref.monthCellRender,
|
|
cellRender = _ref.cellRender;
|
|
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,
|
|
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 = useMergedState(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 = useMergedState(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 = useMergedState(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 || dateUtil_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 && !dateUtil_isEqual(generateConfig, date, mergedValue) && !(disabledDate !== null && disabledDate !== void 0 && disabledDate(date))) {
|
|
onChange(date);
|
|
}
|
|
}
|
|
};
|
|
var isSelectable = function isSelectable(key) {
|
|
if (CALENDAR_PANEL_MODE.includes(mergedMode)) {
|
|
var _date;
|
|
var operationFnc;
|
|
var isDateMode = mergedMode === 'date';
|
|
if (key === es_KeyCode.PAGE_UP || key === es_KeyCode.PAGE_DOWN) {
|
|
operationFnc = isDateMode ? generateConfig.addMonth : generateConfig.addYear;
|
|
} else {
|
|
operationFnc = isDateMode ? generateConfig.addDate : generateConfig.addMonth;
|
|
}
|
|
switch (key) {
|
|
case es_KeyCode.LEFT:
|
|
case es_KeyCode.PAGE_UP:
|
|
_date = operationFnc(viewDate, -1);
|
|
break;
|
|
case es_KeyCode.RIGHT:
|
|
case es_KeyCode.PAGE_DOWN:
|
|
_date = operationFnc(viewDate, 1);
|
|
break;
|
|
case es_KeyCode.UP:
|
|
case es_KeyCode.DOWN:
|
|
_date = operationFnc(viewDate, Number("".concat(key === es_KeyCode.UP ? '-' : '').concat(isDateMode ? WEEK_DAY_COUNT : MONTH_COL_COUNT)));
|
|
break;
|
|
}
|
|
if (_date) {
|
|
return !(disabledDate !== null && disabledDate !== void 0 && disabledDate(_date));
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
// ========================= Interactive ==========================
|
|
var onInternalKeyDown = function onInternalKeyDown(e) {
|
|
if (panelRef.current && panelRef.current.onKeyDown) {
|
|
var selectable = true;
|
|
var which = e.which;
|
|
if ([es_KeyCode.LEFT, es_KeyCode.RIGHT, es_KeyCode.UP, es_KeyCode.DOWN, es_KeyCode.PAGE_UP, es_KeyCode.PAGE_DOWN, es_KeyCode.ENTER].includes(which)) {
|
|
e.preventDefault();
|
|
if (which !== es_KeyCode.ENTER && tabIndex === 0) {
|
|
selectable = isSelectable(which);
|
|
}
|
|
}
|
|
|
|
// Cannot use keyboard to select disabled date
|
|
if (selectable) {
|
|
return panelRef.current.onKeyDown(e);
|
|
}
|
|
}
|
|
|
|
/* istanbul ignore next */
|
|
/* eslint-disable no-lone-blocks */
|
|
{
|
|
es_warning(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 mergedCellRender = useCellRender({
|
|
cellRender: cellRender,
|
|
monthCellRender: monthCellRender,
|
|
dateRender: dateRender
|
|
});
|
|
var pickerProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, props), {}, {
|
|
cellRender: mergedCellRender,
|
|
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] // second
|
|
);
|
|
|
|
triggerSelect(adjustedNow, 'submit');
|
|
};
|
|
if (!hideRanges) {
|
|
extraFooter = getExtraFooter(prefixCls, mergedMode, renderExtraFooter);
|
|
|
|
// This content is not displayed when the header switches year and month
|
|
if (showTime && mergedMode !== 'date') {
|
|
rangesNode = null;
|
|
} else {
|
|
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
|
|
}, 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/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/react-dom/index.js
|
|
var react_dom = __webpack_require__(73935);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/Dom/canUseDom.js
|
|
function canUseDom_canUseDom() {
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/warning.js
|
|
/* eslint-disable no-console */
|
|
var warning_warned = {};
|
|
function es_warning_warning(valid, message) {
|
|
// Support uglify
|
|
if (false) {}
|
|
}
|
|
function warning_note(valid, message) {
|
|
// Support uglify
|
|
if (false) {}
|
|
}
|
|
function warning_resetWarned() {
|
|
warning_warned = {};
|
|
}
|
|
function warning_call(method, valid, message) {
|
|
if (!valid && !warning_warned[message]) {
|
|
method(false, message);
|
|
warning_warned[message] = true;
|
|
}
|
|
}
|
|
function warning_warningOnce(valid, message) {
|
|
warning_call(es_warning_warning, valid, message);
|
|
}
|
|
function warning_noteOnce(valid, message) {
|
|
warning_call(warning_note, valid, message);
|
|
}
|
|
/* harmony default export */ var rc_util_es_warning = ((/* unused pure expression or super */ null && (warning_warningOnce)));
|
|
/* eslint-enable */
|
|
// EXTERNAL MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/react-is/index.js
|
|
var react_is = __webpack_require__(49286);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/hooks/useMemo.js
|
|
|
|
function hooks_useMemo_useMemo(getValue, condition, shouldUpdate) {
|
|
var cacheRef = react.useRef({});
|
|
if (!('value' in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
|
|
cacheRef.current.value = getValue();
|
|
cacheRef.current.condition = condition;
|
|
}
|
|
return cacheRef.current.value;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/ref.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
|
|
function fillRef(ref, node) {
|
|
if (typeof ref === 'function') {
|
|
ref(node);
|
|
} else if ((0,esm_typeof/* default */.Z)(ref) === 'object' && ref && 'current' in ref) {
|
|
ref.current = node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge refs into one ref function to support ref passing.
|
|
*/
|
|
function composeRef() {
|
|
for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
refs[_key] = arguments[_key];
|
|
}
|
|
var refList = refs.filter(function (ref) {
|
|
return ref;
|
|
});
|
|
if (refList.length <= 1) {
|
|
return refList[0];
|
|
}
|
|
return function (node) {
|
|
refs.forEach(function (ref) {
|
|
fillRef(ref, node);
|
|
});
|
|
};
|
|
}
|
|
function useComposeRef() {
|
|
for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
refs[_key2] = arguments[_key2];
|
|
}
|
|
return hooks_useMemo_useMemo(function () {
|
|
return composeRef.apply(void 0, refs);
|
|
}, refs, function (prev, next) {
|
|
return prev.length === next.length && prev.every(function (ref, i) {
|
|
return ref === next[i];
|
|
});
|
|
});
|
|
}
|
|
function supportRef(nodeOrComponent) {
|
|
var _type$prototype, _nodeOrComponent$prot;
|
|
var type = (0,react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
|
|
|
|
// Function component node
|
|
if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
|
|
return false;
|
|
}
|
|
|
|
// Class component
|
|
if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/Context.js
|
|
|
|
var OrderContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var Context = (OrderContext);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
|
|
|
|
|
|
/**
|
|
* Wrap `React.useLayoutEffect` which will not throw warning message in test env
|
|
*/
|
|
var useLayoutEffect_useLayoutEffect = true && canUseDom_canUseDom() ? react.useLayoutEffect : react.useEffect;
|
|
/* harmony default export */ var es_hooks_useLayoutEffect = (useLayoutEffect_useLayoutEffect);
|
|
var useLayoutEffect_useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
|
|
var firstMountRef = React.useRef(true);
|
|
useLayoutEffect_useLayoutEffect(function () {
|
|
if (!firstMountRef.current) {
|
|
return callback();
|
|
}
|
|
}, deps);
|
|
|
|
// We tell react that first mount has passed
|
|
useLayoutEffect_useLayoutEffect(function () {
|
|
firstMountRef.current = false;
|
|
return function () {
|
|
firstMountRef.current = true;
|
|
};
|
|
}, []);
|
|
};
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/useDom.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var EMPTY_LIST = [];
|
|
|
|
/**
|
|
* Will add `div` to document. Nest call will keep order
|
|
* @param render Render DOM in document
|
|
*/
|
|
function useDom(render, debug) {
|
|
var _React$useState = react.useState(function () {
|
|
if (!canUseDom_canUseDom()) {
|
|
return null;
|
|
}
|
|
var defaultEle = document.createElement('div');
|
|
if (false) {}
|
|
return defaultEle;
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 1),
|
|
ele = _React$useState2[0];
|
|
|
|
// ========================== Order ==========================
|
|
var appendedRef = react.useRef(false);
|
|
var queueCreate = react.useContext(Context);
|
|
var _React$useState3 = react.useState(EMPTY_LIST),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
queue = _React$useState4[0],
|
|
setQueue = _React$useState4[1];
|
|
var mergedQueueCreate = queueCreate || (appendedRef.current ? undefined : function (appendFn) {
|
|
setQueue(function (origin) {
|
|
var newQueue = [appendFn].concat((0,toConsumableArray/* default */.Z)(origin));
|
|
return newQueue;
|
|
});
|
|
});
|
|
|
|
// =========================== DOM ===========================
|
|
function append() {
|
|
if (!ele.parentElement) {
|
|
document.body.appendChild(ele);
|
|
}
|
|
appendedRef.current = true;
|
|
}
|
|
function cleanup() {
|
|
var _ele$parentElement;
|
|
(_ele$parentElement = ele.parentElement) === null || _ele$parentElement === void 0 ? void 0 : _ele$parentElement.removeChild(ele);
|
|
appendedRef.current = false;
|
|
}
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (render) {
|
|
if (queueCreate) {
|
|
queueCreate(append);
|
|
} else {
|
|
append();
|
|
}
|
|
} else {
|
|
cleanup();
|
|
}
|
|
return cleanup;
|
|
}, [render]);
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (queue.length) {
|
|
queue.forEach(function (appendFn) {
|
|
return appendFn();
|
|
});
|
|
setQueue(EMPTY_LIST);
|
|
}
|
|
}, [queue]);
|
|
return [ele, mergedQueueCreate];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/Dom/contains.js
|
|
function contains(root, n) {
|
|
if (!root) {
|
|
return false;
|
|
}
|
|
|
|
// Use native if support
|
|
if (root.contains) {
|
|
return root.contains(n);
|
|
}
|
|
|
|
// `document.contains` not support with IE11
|
|
var node = n;
|
|
while (node) {
|
|
if (node === root) {
|
|
return true;
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/Dom/dynamicCSS.js
|
|
|
|
|
|
var APPEND_ORDER = 'data-rc-order';
|
|
var MARK_KEY = "rc-util-key";
|
|
var containerCache = new Map();
|
|
function getMark() {
|
|
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
|
|
mark = _ref.mark;
|
|
if (mark) {
|
|
return mark.startsWith('data-') ? mark : "data-".concat(mark);
|
|
}
|
|
return MARK_KEY;
|
|
}
|
|
function getContainer(option) {
|
|
if (option.attachTo) {
|
|
return option.attachTo;
|
|
}
|
|
var head = document.querySelector('head');
|
|
return head || document.body;
|
|
}
|
|
function getOrder(prepend) {
|
|
if (prepend === 'queue') {
|
|
return 'prependQueue';
|
|
}
|
|
return prepend ? 'prepend' : 'append';
|
|
}
|
|
|
|
/**
|
|
* Find style which inject by rc-util
|
|
*/
|
|
function findStyles(container) {
|
|
return Array.from((containerCache.get(container) || container).children).filter(function (node) {
|
|
return node.tagName === 'STYLE';
|
|
});
|
|
}
|
|
function injectCSS(css) {
|
|
var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
if (!canUseDom_canUseDom()) {
|
|
return null;
|
|
}
|
|
var csp = option.csp,
|
|
prepend = option.prepend;
|
|
var styleNode = document.createElement('style');
|
|
styleNode.setAttribute(APPEND_ORDER, getOrder(prepend));
|
|
if (csp !== null && csp !== void 0 && csp.nonce) {
|
|
styleNode.nonce = csp === null || csp === void 0 ? void 0 : csp.nonce;
|
|
}
|
|
styleNode.innerHTML = css;
|
|
var container = getContainer(option);
|
|
var firstChild = container.firstChild;
|
|
if (prepend) {
|
|
// If is queue `prepend`, it will prepend first style and then append rest style
|
|
if (prepend === 'queue') {
|
|
var existStyle = findStyles(container).filter(function (node) {
|
|
return ['prepend', 'prependQueue'].includes(node.getAttribute(APPEND_ORDER));
|
|
});
|
|
if (existStyle.length) {
|
|
container.insertBefore(styleNode, existStyle[existStyle.length - 1].nextSibling);
|
|
return styleNode;
|
|
}
|
|
}
|
|
|
|
// Use `insertBefore` as `prepend`
|
|
container.insertBefore(styleNode, firstChild);
|
|
} else {
|
|
container.appendChild(styleNode);
|
|
}
|
|
return styleNode;
|
|
}
|
|
function findExistNode(key) {
|
|
var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var container = getContainer(option);
|
|
return findStyles(container).find(function (node) {
|
|
return node.getAttribute(getMark(option)) === key;
|
|
});
|
|
}
|
|
function removeCSS(key) {
|
|
var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var existNode = findExistNode(key, option);
|
|
if (existNode) {
|
|
var container = getContainer(option);
|
|
container.removeChild(existNode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* qiankun will inject `appendChild` to insert into other
|
|
*/
|
|
function syncRealContainer(container, option) {
|
|
var cachedRealContainer = containerCache.get(container);
|
|
|
|
// Find real container when not cached or cached container removed
|
|
if (!cachedRealContainer || !contains(document, cachedRealContainer)) {
|
|
var placeholderStyle = injectCSS('', option);
|
|
var parentNode = placeholderStyle.parentNode;
|
|
containerCache.set(container, parentNode);
|
|
container.removeChild(placeholderStyle);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* manually clear container cache to avoid global cache in unit testes
|
|
*/
|
|
function clearContainerCache() {
|
|
containerCache.clear();
|
|
}
|
|
function updateCSS(css, key) {
|
|
var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
var container = getContainer(option);
|
|
|
|
// Sync real parent
|
|
syncRealContainer(container, option);
|
|
var existNode = findExistNode(key, option);
|
|
if (existNode) {
|
|
var _option$csp, _option$csp2;
|
|
if ((_option$csp = option.csp) !== null && _option$csp !== void 0 && _option$csp.nonce && existNode.nonce !== ((_option$csp2 = option.csp) === null || _option$csp2 === void 0 ? void 0 : _option$csp2.nonce)) {
|
|
var _option$csp3;
|
|
existNode.nonce = (_option$csp3 = option.csp) === null || _option$csp3 === void 0 ? void 0 : _option$csp3.nonce;
|
|
}
|
|
if (existNode.innerHTML !== css) {
|
|
existNode.innerHTML = css;
|
|
}
|
|
return existNode;
|
|
}
|
|
var newNode = injectCSS(css, option);
|
|
newNode.setAttribute(getMark(option), key);
|
|
return newNode;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/node_modules/rc-util/es/getScrollBarSize.js
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
var cached;
|
|
function getScrollBarSize(fresh) {
|
|
if (typeof document === 'undefined') {
|
|
return 0;
|
|
}
|
|
if (fresh || cached === undefined) {
|
|
var inner = document.createElement('div');
|
|
inner.style.width = '100%';
|
|
inner.style.height = '200px';
|
|
var outer = document.createElement('div');
|
|
var outerStyle = outer.style;
|
|
outerStyle.position = 'absolute';
|
|
outerStyle.top = '0';
|
|
outerStyle.left = '0';
|
|
outerStyle.pointerEvents = 'none';
|
|
outerStyle.visibility = 'hidden';
|
|
outerStyle.width = '200px';
|
|
outerStyle.height = '150px';
|
|
outerStyle.overflow = 'hidden';
|
|
outer.appendChild(inner);
|
|
document.body.appendChild(outer);
|
|
var widthContained = inner.offsetWidth;
|
|
outer.style.overflow = 'scroll';
|
|
var widthScroll = inner.offsetWidth;
|
|
if (widthContained === widthScroll) {
|
|
widthScroll = outer.clientWidth;
|
|
}
|
|
document.body.removeChild(outer);
|
|
cached = widthContained - widthScroll;
|
|
}
|
|
return cached;
|
|
}
|
|
function ensureSize(str) {
|
|
var match = str.match(/^(.*)px$/);
|
|
var value = Number(match === null || match === void 0 ? void 0 : match[1]);
|
|
return Number.isNaN(value) ? getScrollBarSize() : value;
|
|
}
|
|
function getTargetScrollBarSize(target) {
|
|
if (typeof document === 'undefined' || !target || !(target instanceof Element)) {
|
|
return {
|
|
width: 0,
|
|
height: 0
|
|
};
|
|
}
|
|
var _getComputedStyle = getComputedStyle(target, '::-webkit-scrollbar'),
|
|
width = _getComputedStyle.width,
|
|
height = _getComputedStyle.height;
|
|
return {
|
|
width: ensureSize(width),
|
|
height: ensureSize(height)
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/util.js
|
|
/**
|
|
* Test usage export. Do not use in your production
|
|
*/
|
|
function isBodyOverflowing() {
|
|
return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) && window.innerWidth > document.body.offsetWidth;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/useScrollLocker.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var UNIQUE_ID = "rc-util-locker-".concat(Date.now());
|
|
var uuid = 0;
|
|
function useScrollLocker(lock) {
|
|
var mergedLock = !!lock;
|
|
var _React$useState = react.useState(function () {
|
|
uuid += 1;
|
|
return "".concat(UNIQUE_ID, "_").concat(uuid);
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 1),
|
|
id = _React$useState2[0];
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (mergedLock) {
|
|
var scrollbarSize = getTargetScrollBarSize(document.body).width;
|
|
var isOverflow = isBodyOverflowing();
|
|
updateCSS("\nhtml body {\n overflow-y: hidden;\n ".concat(isOverflow ? "width: calc(100% - ".concat(scrollbarSize, "px);") : '', "\n}"), id);
|
|
} else {
|
|
removeCSS(id);
|
|
}
|
|
return function () {
|
|
removeCSS(id);
|
|
};
|
|
}, [mergedLock, id]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/mock.js
|
|
var inline = false;
|
|
function inlineMock(nextInline) {
|
|
if (typeof nextInline === 'boolean') {
|
|
inline = nextInline;
|
|
}
|
|
return inline;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/Portal.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var getPortalContainer = function getPortalContainer(getContainer) {
|
|
if (getContainer === false) {
|
|
return false;
|
|
}
|
|
if (!canUseDom_canUseDom() || !getContainer) {
|
|
return null;
|
|
}
|
|
if (typeof getContainer === 'string') {
|
|
return document.querySelector(getContainer);
|
|
}
|
|
if (typeof getContainer === 'function') {
|
|
return getContainer();
|
|
}
|
|
return getContainer;
|
|
};
|
|
var Portal = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var open = props.open,
|
|
autoLock = props.autoLock,
|
|
getContainer = props.getContainer,
|
|
debug = props.debug,
|
|
_props$autoDestroy = props.autoDestroy,
|
|
autoDestroy = _props$autoDestroy === void 0 ? true : _props$autoDestroy,
|
|
children = props.children;
|
|
var _React$useState = react.useState(open),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
shouldRender = _React$useState2[0],
|
|
setShouldRender = _React$useState2[1];
|
|
var mergedRender = shouldRender || open;
|
|
|
|
// ========================= Warning =========================
|
|
if (false) {}
|
|
|
|
// ====================== Should Render ======================
|
|
react.useEffect(function () {
|
|
if (autoDestroy || open) {
|
|
setShouldRender(open);
|
|
}
|
|
}, [open, autoDestroy]);
|
|
|
|
// ======================== Container ========================
|
|
var _React$useState3 = react.useState(function () {
|
|
return getPortalContainer(getContainer);
|
|
}),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
innerContainer = _React$useState4[0],
|
|
setInnerContainer = _React$useState4[1];
|
|
react.useEffect(function () {
|
|
var customizeContainer = getPortalContainer(getContainer);
|
|
|
|
// Tell component that we check this in effect which is safe to be `null`
|
|
setInnerContainer(customizeContainer !== null && customizeContainer !== void 0 ? customizeContainer : null);
|
|
});
|
|
var _useDom = useDom(mergedRender && !innerContainer, debug),
|
|
_useDom2 = (0,slicedToArray/* default */.Z)(_useDom, 2),
|
|
defaultContainer = _useDom2[0],
|
|
queueCreate = _useDom2[1];
|
|
var mergedContainer = innerContainer !== null && innerContainer !== void 0 ? innerContainer : defaultContainer;
|
|
|
|
// ========================= Locker ==========================
|
|
useScrollLocker(autoLock && open && canUseDom_canUseDom() && (mergedContainer === defaultContainer || mergedContainer === document.body));
|
|
|
|
// =========================== Ref ===========================
|
|
var childRef = null;
|
|
if (children && supportRef(children) && ref) {
|
|
var _ref = children;
|
|
childRef = _ref.ref;
|
|
}
|
|
var mergedRef = useComposeRef(childRef, ref);
|
|
|
|
// ========================= Render ==========================
|
|
// Do not render when nothing need render
|
|
// When innerContainer is `undefined`, it may not ready since user use ref in the same render
|
|
if (!mergedRender || !canUseDom_canUseDom() || innerContainer === undefined) {
|
|
return null;
|
|
}
|
|
|
|
// Render inline
|
|
var renderInline = mergedContainer === false || inlineMock();
|
|
var reffedChildren = children;
|
|
if (ref) {
|
|
reffedChildren = /*#__PURE__*/react.cloneElement(children, {
|
|
ref: mergedRef
|
|
});
|
|
}
|
|
return /*#__PURE__*/react.createElement(Context.Provider, {
|
|
value: queueCreate
|
|
}, renderInline ? reffedChildren : /*#__PURE__*/(0,react_dom.createPortal)(reffedChildren, mergedContainer));
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var es_Portal = (Portal);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/portal/es/index.js
|
|
|
|
|
|
|
|
/* harmony default export */ var es = (es_Portal);
|
|
// EXTERNAL MODULE: ./node_modules/rc-resize-observer/es/index.js + 4 modules
|
|
var rc_resize_observer_es = __webpack_require__(48555);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/Dom/findDOMNode.js
|
|
|
|
|
|
function isDOM(node) {
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element
|
|
// Since XULElement is also subclass of Element, we only need HTMLElement and SVGElement
|
|
return node instanceof HTMLElement || node instanceof SVGElement;
|
|
}
|
|
|
|
/**
|
|
* Return if a node is a DOM node. Else will return by `findDOMNode`
|
|
*/
|
|
function findDOMNode(node) {
|
|
if (isDOM(node)) {
|
|
return node;
|
|
}
|
|
if (node instanceof React.Component) {
|
|
return ReactDOM.findDOMNode(node);
|
|
}
|
|
return null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/Dom/shadow.js
|
|
function getRoot(ele) {
|
|
var _ele$getRootNode;
|
|
return ele === null || ele === void 0 ? void 0 : (_ele$getRootNode = ele.getRootNode) === null || _ele$getRootNode === void 0 ? void 0 : _ele$getRootNode.call(ele);
|
|
}
|
|
|
|
/**
|
|
* Check if is in shadowRoot
|
|
*/
|
|
function inShadow(ele) {
|
|
return getRoot(ele) !== (ele === null || ele === void 0 ? void 0 : ele.ownerDocument);
|
|
}
|
|
|
|
/**
|
|
* Return shadowRoot if possible
|
|
*/
|
|
function getShadowRoot(ele) {
|
|
return inShadow(ele) ? getRoot(ele) : null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/hooks/useId.js
|
|
|
|
|
|
|
|
function getUseId() {
|
|
// We need fully clone React function here to avoid webpack warning React 17 do not export `useId`
|
|
var fullClone = (0,objectSpread2/* default */.Z)({}, react_namespaceObject);
|
|
return fullClone.useId;
|
|
}
|
|
var useId_uuid = 0;
|
|
|
|
/** @private Note only worked in develop env. Not work in production. */
|
|
function resetUuid() {
|
|
if (false) {}
|
|
}
|
|
function useId(id) {
|
|
// Inner id for accessibility usage. Only work in client side
|
|
var _React$useState = react.useState('ssr-id'),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
innerId = _React$useState2[0],
|
|
setInnerId = _React$useState2[1];
|
|
var useOriginId = getUseId();
|
|
var reactNativeId = useOriginId === null || useOriginId === void 0 ? void 0 : useOriginId();
|
|
react.useEffect(function () {
|
|
if (!useOriginId) {
|
|
var nextId = useId_uuid;
|
|
useId_uuid += 1;
|
|
setInnerId("rc_unique_".concat(nextId));
|
|
}
|
|
}, []);
|
|
|
|
// Developer passed id is single source of truth
|
|
if (id) {
|
|
return id;
|
|
}
|
|
|
|
// Test env always return mock id
|
|
if (false) {}
|
|
|
|
// Return react native id or inner id
|
|
return reactNativeId || innerId;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/isMobile.js
|
|
/* harmony default export */ var isMobile = (function () {
|
|
if (typeof navigator === 'undefined' || typeof window === 'undefined') {
|
|
return false;
|
|
}
|
|
var agent = navigator.userAgent || navigator.vendor || window.opera;
|
|
return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent === null || agent === void 0 ? void 0 : agent.substr(0, 4));
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/context.js
|
|
|
|
var TriggerContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var es_context = (TriggerContext);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/hooks/useAction.js
|
|
|
|
function useAction_toArray(val) {
|
|
return val ? Array.isArray(val) ? val : [val] : [];
|
|
}
|
|
function useAction(mobile, action, showAction, hideAction) {
|
|
return react.useMemo(function () {
|
|
var mergedShowAction = useAction_toArray(showAction !== null && showAction !== void 0 ? showAction : action);
|
|
var mergedHideAction = useAction_toArray(hideAction !== null && hideAction !== void 0 ? hideAction : action);
|
|
var showActionSet = new Set(mergedShowAction);
|
|
var hideActionSet = new Set(mergedHideAction);
|
|
if (mobile) {
|
|
if (showActionSet.has('hover')) {
|
|
showActionSet.delete('hover');
|
|
showActionSet.add('click');
|
|
}
|
|
if (hideActionSet.has('hover')) {
|
|
hideActionSet.delete('hover');
|
|
hideActionSet.add('click');
|
|
}
|
|
}
|
|
return [showActionSet, hideActionSet];
|
|
}, [mobile, action, showAction, hideAction]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/util.js
|
|
|
|
function isPointsEq() {
|
|
var a1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
var a2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
var isAlignPoint = arguments.length > 2 ? arguments[2] : undefined;
|
|
if (isAlignPoint) {
|
|
return a1[0] === a2[0];
|
|
}
|
|
return a1[0] === a2[0] && a1[1] === a2[1];
|
|
}
|
|
function getAlignPopupClassName(builtinPlacements, prefixCls, align, isAlignPoint) {
|
|
var points = align.points;
|
|
var placements = Object.keys(builtinPlacements);
|
|
for (var i = 0; i < placements.length; i += 1) {
|
|
var _builtinPlacements$pl;
|
|
var placement = placements[i];
|
|
if (isPointsEq((_builtinPlacements$pl = builtinPlacements[placement]) === null || _builtinPlacements$pl === void 0 ? void 0 : _builtinPlacements$pl.points, points, isAlignPoint)) {
|
|
return "".concat(prefixCls, "-placement-").concat(placement);
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/** @deprecated We should not use this if we can refactor all deps */
|
|
function getMotion(prefixCls, motion, animation, transitionName) {
|
|
if (motion) {
|
|
return motion;
|
|
}
|
|
if (animation) {
|
|
return {
|
|
motionName: "".concat(prefixCls, "-").concat(animation)
|
|
};
|
|
}
|
|
if (transitionName) {
|
|
return {
|
|
motionName: transitionName
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
function getWin(ele) {
|
|
return ele.ownerDocument.defaultView;
|
|
}
|
|
|
|
/**
|
|
* Get all the scrollable parent elements of the element
|
|
* @param ele The element to be detected
|
|
* @param areaOnly Only return the parent which will cut visible area
|
|
*/
|
|
function collectScroller(ele) {
|
|
var scrollerList = [];
|
|
var current = ele === null || ele === void 0 ? void 0 : ele.parentElement;
|
|
var scrollStyle = ['hidden', 'scroll', 'clip', 'auto'];
|
|
while (current) {
|
|
var _getWin$getComputedSt = getWin(current).getComputedStyle(current),
|
|
overflowX = _getWin$getComputedSt.overflowX,
|
|
overflowY = _getWin$getComputedSt.overflowY,
|
|
overflow = _getWin$getComputedSt.overflow;
|
|
if ([overflowX, overflowY, overflow].some(function (o) {
|
|
return scrollStyle.includes(o);
|
|
})) {
|
|
scrollerList.push(current);
|
|
}
|
|
current = current.parentElement;
|
|
}
|
|
return scrollerList;
|
|
}
|
|
function toNum(num) {
|
|
var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
return Number.isNaN(num) ? defaultValue : num;
|
|
}
|
|
function getPxValue(val) {
|
|
return toNum(parseFloat(val), 0);
|
|
}
|
|
/**
|
|
*
|
|
*
|
|
* **************************************
|
|
* * Border *
|
|
* * ************************** *
|
|
* * * * * *
|
|
* * B * * S * B *
|
|
* * o * * c * o *
|
|
* * r * Content * r * r *
|
|
* * d * * o * d *
|
|
* * e * * l * e *
|
|
* * r ******************** l * r *
|
|
* * * Scroll * *
|
|
* * ************************** *
|
|
* * Border *
|
|
* **************************************
|
|
*
|
|
*/
|
|
/**
|
|
* Get visible area of element
|
|
*/
|
|
function getVisibleArea(initArea, scrollerList) {
|
|
var visibleArea = (0,objectSpread2/* default */.Z)({}, initArea);
|
|
(scrollerList || []).forEach(function (ele) {
|
|
if (ele instanceof HTMLBodyElement) {
|
|
return;
|
|
}
|
|
|
|
// Skip if static position which will not affect visible area
|
|
var _getWin$getComputedSt2 = getWin(ele).getComputedStyle(ele),
|
|
overflow = _getWin$getComputedSt2.overflow,
|
|
overflowClipMargin = _getWin$getComputedSt2.overflowClipMargin,
|
|
borderTopWidth = _getWin$getComputedSt2.borderTopWidth,
|
|
borderBottomWidth = _getWin$getComputedSt2.borderBottomWidth,
|
|
borderLeftWidth = _getWin$getComputedSt2.borderLeftWidth,
|
|
borderRightWidth = _getWin$getComputedSt2.borderRightWidth;
|
|
var eleRect = ele.getBoundingClientRect();
|
|
var eleOutHeight = ele.offsetHeight,
|
|
eleInnerHeight = ele.clientHeight,
|
|
eleOutWidth = ele.offsetWidth,
|
|
eleInnerWidth = ele.clientWidth;
|
|
var borderTopNum = getPxValue(borderTopWidth);
|
|
var borderBottomNum = getPxValue(borderBottomWidth);
|
|
var borderLeftNum = getPxValue(borderLeftWidth);
|
|
var borderRightNum = getPxValue(borderRightWidth);
|
|
var scaleX = toNum(Math.round(eleRect.width / eleOutWidth * 1000) / 1000);
|
|
var scaleY = toNum(Math.round(eleRect.height / eleOutHeight * 1000) / 1000);
|
|
|
|
// Original visible area
|
|
var eleScrollWidth = (eleOutWidth - eleInnerWidth - borderLeftNum - borderRightNum) * scaleX;
|
|
var eleScrollHeight = (eleOutHeight - eleInnerHeight - borderTopNum - borderBottomNum) * scaleY;
|
|
|
|
// Cut border size
|
|
var scaledBorderTopWidth = borderTopNum * scaleY;
|
|
var scaledBorderBottomWidth = borderBottomNum * scaleY;
|
|
var scaledBorderLeftWidth = borderLeftNum * scaleX;
|
|
var scaledBorderRightWidth = borderRightNum * scaleX;
|
|
|
|
// Clip margin
|
|
var clipMarginWidth = 0;
|
|
var clipMarginHeight = 0;
|
|
if (overflow === 'clip') {
|
|
var clipNum = getPxValue(overflowClipMargin);
|
|
clipMarginWidth = clipNum * scaleX;
|
|
clipMarginHeight = clipNum * scaleY;
|
|
}
|
|
|
|
// Region
|
|
var eleLeft = eleRect.x + scaledBorderLeftWidth - clipMarginWidth;
|
|
var eleTop = eleRect.y + scaledBorderTopWidth - clipMarginHeight;
|
|
var eleRight = eleLeft + eleRect.width + 2 * clipMarginWidth - scaledBorderLeftWidth - scaledBorderRightWidth - eleScrollWidth;
|
|
var eleBottom = eleTop + eleRect.height + 2 * clipMarginHeight - scaledBorderTopWidth - scaledBorderBottomWidth - eleScrollHeight;
|
|
visibleArea.left = Math.max(visibleArea.left, eleLeft);
|
|
visibleArea.top = Math.max(visibleArea.top, eleTop);
|
|
visibleArea.right = Math.min(visibleArea.right, eleRight);
|
|
visibleArea.bottom = Math.min(visibleArea.bottom, eleBottom);
|
|
});
|
|
return visibleArea;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/hooks/useAlign.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function getUnitOffset(size) {
|
|
var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
var offsetStr = "".concat(offset);
|
|
var cells = offsetStr.match(/^(.*)\%$/);
|
|
if (cells) {
|
|
return size * (parseFloat(cells[1]) / 100);
|
|
}
|
|
return parseFloat(offsetStr);
|
|
}
|
|
function getNumberOffset(rect, offset) {
|
|
var _ref = offset || [],
|
|
_ref2 = (0,slicedToArray/* default */.Z)(_ref, 2),
|
|
offsetX = _ref2[0],
|
|
offsetY = _ref2[1];
|
|
return [getUnitOffset(rect.width, offsetX), getUnitOffset(rect.height, offsetY)];
|
|
}
|
|
function splitPoints() {
|
|
var points = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
|
return [points[0], points[1]];
|
|
}
|
|
function getAlignPoint(rect, points) {
|
|
var topBottom = points[0];
|
|
var leftRight = points[1];
|
|
var x;
|
|
var y;
|
|
|
|
// Top & Bottom
|
|
if (topBottom === 't') {
|
|
y = rect.y;
|
|
} else if (topBottom === 'b') {
|
|
y = rect.y + rect.height;
|
|
} else {
|
|
y = rect.y + rect.height / 2;
|
|
}
|
|
|
|
// Left & Right
|
|
if (leftRight === 'l') {
|
|
x = rect.x;
|
|
} else if (leftRight === 'r') {
|
|
x = rect.x + rect.width;
|
|
} else {
|
|
x = rect.x + rect.width / 2;
|
|
}
|
|
return {
|
|
x: x,
|
|
y: y
|
|
};
|
|
}
|
|
function reversePoints(points, index) {
|
|
var reverseMap = {
|
|
t: 'b',
|
|
b: 't',
|
|
l: 'r',
|
|
r: 'l'
|
|
};
|
|
return points.map(function (point, i) {
|
|
if (i === index) {
|
|
return reverseMap[point] || 'c';
|
|
}
|
|
return point;
|
|
}).join('');
|
|
}
|
|
function useAlign(open, popupEle, target, placement, builtinPlacements, popupAlign, onPopupAlign) {
|
|
var _React$useState = react.useState({
|
|
ready: false,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
offsetR: 0,
|
|
offsetB: 0,
|
|
arrowX: 0,
|
|
arrowY: 0,
|
|
scaleX: 1,
|
|
scaleY: 1,
|
|
align: builtinPlacements[placement] || {}
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
offsetInfo = _React$useState2[0],
|
|
setOffsetInfo = _React$useState2[1];
|
|
var alignCountRef = react.useRef(0);
|
|
var scrollerList = react.useMemo(function () {
|
|
if (!popupEle) {
|
|
return [];
|
|
}
|
|
return collectScroller(popupEle);
|
|
}, [popupEle]);
|
|
|
|
// ========================= Flip ==========================
|
|
// We will memo flip info.
|
|
// If size change to make flip, it will memo the flip info and use it in next align.
|
|
var prevFlipRef = react.useRef({});
|
|
var resetFlipCache = function resetFlipCache() {
|
|
prevFlipRef.current = {};
|
|
};
|
|
if (!open) {
|
|
resetFlipCache();
|
|
}
|
|
|
|
// ========================= Align =========================
|
|
var onAlign = useEvent(function () {
|
|
if (popupEle && target && open) {
|
|
var popupElement = popupEle;
|
|
var originLeft = popupElement.style.left;
|
|
var originTop = popupElement.style.top;
|
|
var originRight = popupElement.style.right;
|
|
var originBottom = popupElement.style.bottom;
|
|
var doc = popupElement.ownerDocument;
|
|
var win = getWin(popupElement);
|
|
|
|
// Placement
|
|
var placementInfo = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, builtinPlacements[placement]), popupAlign);
|
|
|
|
// Reset first
|
|
popupElement.style.left = '0';
|
|
popupElement.style.top = '0';
|
|
popupElement.style.right = 'auto';
|
|
popupElement.style.bottom = 'auto';
|
|
|
|
// Calculate align style, we should consider `transform` case
|
|
var targetRect;
|
|
if (Array.isArray(target)) {
|
|
targetRect = {
|
|
x: target[0],
|
|
y: target[1],
|
|
width: 0,
|
|
height: 0
|
|
};
|
|
} else {
|
|
var rect = target.getBoundingClientRect();
|
|
targetRect = {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
width: rect.width,
|
|
height: rect.height
|
|
};
|
|
}
|
|
var popupRect = popupElement.getBoundingClientRect();
|
|
var _win$getComputedStyle = win.getComputedStyle(popupElement),
|
|
width = _win$getComputedStyle.width,
|
|
height = _win$getComputedStyle.height;
|
|
var _doc$documentElement = doc.documentElement,
|
|
clientWidth = _doc$documentElement.clientWidth,
|
|
clientHeight = _doc$documentElement.clientHeight,
|
|
scrollWidth = _doc$documentElement.scrollWidth,
|
|
scrollHeight = _doc$documentElement.scrollHeight,
|
|
scrollTop = _doc$documentElement.scrollTop,
|
|
scrollLeft = _doc$documentElement.scrollLeft;
|
|
var popupHeight = popupRect.height;
|
|
var popupWidth = popupRect.width;
|
|
var targetHeight = targetRect.height;
|
|
var targetWidth = targetRect.width;
|
|
|
|
// Get bounding of visible area
|
|
var visibleRegion = {
|
|
left: 0,
|
|
top: 0,
|
|
right: clientWidth,
|
|
bottom: clientHeight
|
|
};
|
|
var scrollRegion = {
|
|
left: -scrollLeft,
|
|
top: -scrollTop,
|
|
right: scrollWidth - scrollLeft,
|
|
bottom: scrollHeight - scrollTop
|
|
};
|
|
var htmlRegion = placementInfo.htmlRegion;
|
|
var VISIBLE = 'visible';
|
|
var VISIBLE_FIRST = 'visibleFirst';
|
|
if (htmlRegion !== 'scroll' && htmlRegion !== VISIBLE_FIRST) {
|
|
htmlRegion = VISIBLE;
|
|
}
|
|
var isVisibleFirst = htmlRegion === VISIBLE_FIRST;
|
|
var scrollRegionArea = getVisibleArea(scrollRegion, scrollerList);
|
|
var visibleRegionArea = getVisibleArea(visibleRegion, scrollerList);
|
|
var visibleArea = htmlRegion === VISIBLE ? visibleRegionArea : scrollRegionArea;
|
|
|
|
// When set to `visibleFirst`,
|
|
// the check `adjust` logic will use `visibleRegion` for check first.
|
|
var adjustCheckVisibleArea = isVisibleFirst ? visibleRegionArea : visibleArea;
|
|
|
|
// Record right & bottom align data
|
|
popupElement.style.left = 'auto';
|
|
popupElement.style.top = 'auto';
|
|
popupElement.style.right = '0';
|
|
popupElement.style.bottom = '0';
|
|
var popupMirrorRect = popupElement.getBoundingClientRect();
|
|
|
|
// Reset back
|
|
popupElement.style.left = originLeft;
|
|
popupElement.style.top = originTop;
|
|
popupElement.style.right = originRight;
|
|
popupElement.style.bottom = originBottom;
|
|
|
|
// Calculate scale
|
|
var _scaleX = toNum(Math.round(popupWidth / parseFloat(width) * 1000) / 1000);
|
|
var _scaleY = toNum(Math.round(popupHeight / parseFloat(height) * 1000) / 1000);
|
|
|
|
// No need to align since it's not visible in view
|
|
if (_scaleX === 0 || _scaleY === 0 || isDOM(target) && !isVisible(target)) {
|
|
return;
|
|
}
|
|
|
|
// Offset
|
|
var offset = placementInfo.offset,
|
|
targetOffset = placementInfo.targetOffset;
|
|
var _getNumberOffset = getNumberOffset(popupRect, offset),
|
|
_getNumberOffset2 = (0,slicedToArray/* default */.Z)(_getNumberOffset, 2),
|
|
popupOffsetX = _getNumberOffset2[0],
|
|
popupOffsetY = _getNumberOffset2[1];
|
|
var _getNumberOffset3 = getNumberOffset(targetRect, targetOffset),
|
|
_getNumberOffset4 = (0,slicedToArray/* default */.Z)(_getNumberOffset3, 2),
|
|
targetOffsetX = _getNumberOffset4[0],
|
|
targetOffsetY = _getNumberOffset4[1];
|
|
targetRect.x -= targetOffsetX;
|
|
targetRect.y -= targetOffsetY;
|
|
|
|
// Points
|
|
var _ref3 = placementInfo.points || [],
|
|
_ref4 = (0,slicedToArray/* default */.Z)(_ref3, 2),
|
|
popupPoint = _ref4[0],
|
|
targetPoint = _ref4[1];
|
|
var targetPoints = splitPoints(targetPoint);
|
|
var popupPoints = splitPoints(popupPoint);
|
|
var targetAlignPoint = getAlignPoint(targetRect, targetPoints);
|
|
var popupAlignPoint = getAlignPoint(popupRect, popupPoints);
|
|
|
|
// Real align info may not same as origin one
|
|
var nextAlignInfo = (0,objectSpread2/* default */.Z)({}, placementInfo);
|
|
|
|
// Next Offset
|
|
var nextOffsetX = targetAlignPoint.x - popupAlignPoint.x + popupOffsetX;
|
|
var nextOffsetY = targetAlignPoint.y - popupAlignPoint.y + popupOffsetY;
|
|
|
|
// ============== Intersection ===============
|
|
// Get area by position. Used for check if flip area is better
|
|
function getIntersectionVisibleArea(offsetX, offsetY) {
|
|
var area = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : visibleArea;
|
|
var l = popupRect.x + offsetX;
|
|
var t = popupRect.y + offsetY;
|
|
var r = l + popupWidth;
|
|
var b = t + popupHeight;
|
|
var visibleL = Math.max(l, area.left);
|
|
var visibleT = Math.max(t, area.top);
|
|
var visibleR = Math.min(r, area.right);
|
|
var visibleB = Math.min(b, area.bottom);
|
|
return Math.max(0, (visibleR - visibleL) * (visibleB - visibleT));
|
|
}
|
|
var originIntersectionVisibleArea = getIntersectionVisibleArea(nextOffsetX, nextOffsetY);
|
|
|
|
// As `visibleFirst`, we prepare this for check
|
|
var originIntersectionRecommendArea = getIntersectionVisibleArea(nextOffsetX, nextOffsetY, visibleRegionArea);
|
|
|
|
// ========================== Overflow ===========================
|
|
var targetAlignPointTL = getAlignPoint(targetRect, ['t', 'l']);
|
|
var popupAlignPointTL = getAlignPoint(popupRect, ['t', 'l']);
|
|
var targetAlignPointBR = getAlignPoint(targetRect, ['b', 'r']);
|
|
var popupAlignPointBR = getAlignPoint(popupRect, ['b', 'r']);
|
|
var overflow = placementInfo.overflow || {};
|
|
var adjustX = overflow.adjustX,
|
|
adjustY = overflow.adjustY,
|
|
shiftX = overflow.shiftX,
|
|
shiftY = overflow.shiftY;
|
|
var supportAdjust = function supportAdjust(val) {
|
|
if (typeof val === 'boolean') {
|
|
return val;
|
|
}
|
|
return val >= 0;
|
|
};
|
|
|
|
// Prepare position
|
|
var nextPopupY;
|
|
var nextPopupBottom;
|
|
var nextPopupX;
|
|
var nextPopupRight;
|
|
function syncNextPopupPosition() {
|
|
nextPopupY = popupRect.y + nextOffsetY;
|
|
nextPopupBottom = nextPopupY + popupHeight;
|
|
nextPopupX = popupRect.x + nextOffsetX;
|
|
nextPopupRight = nextPopupX + popupWidth;
|
|
}
|
|
syncNextPopupPosition();
|
|
|
|
// >>>>>>>>>> Top & Bottom
|
|
var needAdjustY = supportAdjust(adjustY);
|
|
var sameTB = popupPoints[0] === targetPoints[0];
|
|
|
|
// Bottom to Top
|
|
if (needAdjustY && popupPoints[0] === 't' && (nextPopupBottom > adjustCheckVisibleArea.bottom || prevFlipRef.current.bt)) {
|
|
var tmpNextOffsetY = nextOffsetY;
|
|
if (sameTB) {
|
|
tmpNextOffsetY -= popupHeight - targetHeight;
|
|
} else {
|
|
tmpNextOffsetY = targetAlignPointTL.y - popupAlignPointBR.y - popupOffsetY;
|
|
}
|
|
var newVisibleArea = getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY);
|
|
var newVisibleRecommendArea = getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
newVisibleArea > originIntersectionVisibleArea || newVisibleArea === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
newVisibleRecommendArea >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.bt = true;
|
|
nextOffsetY = tmpNextOffsetY;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 0), reversePoints(targetPoints, 0)];
|
|
} else {
|
|
prevFlipRef.current.bt = false;
|
|
}
|
|
}
|
|
|
|
// Top to Bottom
|
|
if (needAdjustY && popupPoints[0] === 'b' && (nextPopupY < adjustCheckVisibleArea.top || prevFlipRef.current.tb)) {
|
|
var _tmpNextOffsetY = nextOffsetY;
|
|
if (sameTB) {
|
|
_tmpNextOffsetY += popupHeight - targetHeight;
|
|
} else {
|
|
_tmpNextOffsetY = targetAlignPointBR.y - popupAlignPointTL.y - popupOffsetY;
|
|
}
|
|
var _newVisibleArea = getIntersectionVisibleArea(nextOffsetX, _tmpNextOffsetY);
|
|
var _newVisibleRecommendArea = getIntersectionVisibleArea(nextOffsetX, _tmpNextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
_newVisibleArea > originIntersectionVisibleArea || _newVisibleArea === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
_newVisibleRecommendArea >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.tb = true;
|
|
nextOffsetY = _tmpNextOffsetY;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 0), reversePoints(targetPoints, 0)];
|
|
} else {
|
|
prevFlipRef.current.tb = false;
|
|
}
|
|
}
|
|
|
|
// >>>>>>>>>> Left & Right
|
|
var needAdjustX = supportAdjust(adjustX);
|
|
|
|
// >>>>> Flip
|
|
var sameLR = popupPoints[1] === targetPoints[1];
|
|
|
|
// Right to Left
|
|
if (needAdjustX && popupPoints[1] === 'l' && (nextPopupRight > adjustCheckVisibleArea.right || prevFlipRef.current.rl)) {
|
|
var tmpNextOffsetX = nextOffsetX;
|
|
if (sameLR) {
|
|
tmpNextOffsetX -= popupWidth - targetWidth;
|
|
} else {
|
|
tmpNextOffsetX = targetAlignPointTL.x - popupAlignPointBR.x - popupOffsetX;
|
|
}
|
|
var _newVisibleArea2 = getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY);
|
|
var _newVisibleRecommendArea2 = getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
_newVisibleArea2 > originIntersectionVisibleArea || _newVisibleArea2 === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
_newVisibleRecommendArea2 >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.rl = true;
|
|
nextOffsetX = tmpNextOffsetX;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 1), reversePoints(targetPoints, 1)];
|
|
} else {
|
|
prevFlipRef.current.rl = false;
|
|
}
|
|
}
|
|
|
|
// Left to Right
|
|
if (needAdjustX && popupPoints[1] === 'r' && (nextPopupX < adjustCheckVisibleArea.left || prevFlipRef.current.lr)) {
|
|
var _tmpNextOffsetX = nextOffsetX;
|
|
if (sameLR) {
|
|
_tmpNextOffsetX += popupWidth - targetWidth;
|
|
} else {
|
|
_tmpNextOffsetX = targetAlignPointBR.x - popupAlignPointTL.x - popupOffsetX;
|
|
}
|
|
var _newVisibleArea3 = getIntersectionVisibleArea(_tmpNextOffsetX, nextOffsetY);
|
|
var _newVisibleRecommendArea3 = getIntersectionVisibleArea(_tmpNextOffsetX, nextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
_newVisibleArea3 > originIntersectionVisibleArea || _newVisibleArea3 === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
_newVisibleRecommendArea3 >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.lr = true;
|
|
nextOffsetX = _tmpNextOffsetX;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 1), reversePoints(targetPoints, 1)];
|
|
} else {
|
|
prevFlipRef.current.lr = false;
|
|
}
|
|
}
|
|
|
|
// ============================ Shift ============================
|
|
syncNextPopupPosition();
|
|
var numShiftX = shiftX === true ? 0 : shiftX;
|
|
if (typeof numShiftX === 'number') {
|
|
// Left
|
|
if (nextPopupX < visibleRegionArea.left) {
|
|
nextOffsetX -= nextPopupX - visibleRegionArea.left;
|
|
if (targetRect.x + targetWidth < visibleRegionArea.left + numShiftX) {
|
|
nextOffsetX += targetRect.x - visibleRegionArea.left + targetWidth - numShiftX;
|
|
}
|
|
}
|
|
|
|
// Right
|
|
if (nextPopupRight > visibleRegionArea.right) {
|
|
nextOffsetX -= nextPopupRight - visibleRegionArea.right;
|
|
if (targetRect.x > visibleRegionArea.right - numShiftX) {
|
|
nextOffsetX += targetRect.x - visibleRegionArea.right + numShiftX;
|
|
}
|
|
}
|
|
}
|
|
var numShiftY = shiftY === true ? 0 : shiftY;
|
|
if (typeof numShiftY === 'number') {
|
|
// Top
|
|
if (nextPopupY < visibleRegionArea.top) {
|
|
nextOffsetY -= nextPopupY - visibleRegionArea.top;
|
|
if (targetRect.y + targetHeight < visibleRegionArea.top + numShiftY) {
|
|
nextOffsetY += targetRect.y - visibleRegionArea.top + targetHeight - numShiftY;
|
|
}
|
|
}
|
|
|
|
// Bottom
|
|
if (nextPopupBottom > visibleRegionArea.bottom) {
|
|
nextOffsetY -= nextPopupBottom - visibleRegionArea.bottom;
|
|
if (targetRect.y > visibleRegionArea.bottom - numShiftY) {
|
|
nextOffsetY += targetRect.y - visibleRegionArea.bottom + numShiftY;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================ Arrow ============================
|
|
// Arrow center align
|
|
var popupLeft = popupRect.x + nextOffsetX;
|
|
var popupRight = popupLeft + popupWidth;
|
|
var popupTop = popupRect.y + nextOffsetY;
|
|
var popupBottom = popupTop + popupHeight;
|
|
var targetLeft = targetRect.x;
|
|
var targetRight = targetLeft + targetWidth;
|
|
var targetTop = targetRect.y;
|
|
var targetBottom = targetTop + targetHeight;
|
|
var maxLeft = Math.max(popupLeft, targetLeft);
|
|
var minRight = Math.min(popupRight, targetRight);
|
|
var xCenter = (maxLeft + minRight) / 2;
|
|
var nextArrowX = xCenter - popupLeft;
|
|
var maxTop = Math.max(popupTop, targetTop);
|
|
var minBottom = Math.min(popupBottom, targetBottom);
|
|
var yCenter = (maxTop + minBottom) / 2;
|
|
var nextArrowY = yCenter - popupTop;
|
|
onPopupAlign === null || onPopupAlign === void 0 ? void 0 : onPopupAlign(popupEle, nextAlignInfo);
|
|
|
|
// Additional calculate right & bottom position
|
|
var offsetX4Right = popupMirrorRect.right - popupRect.x - (nextOffsetX + popupRect.width);
|
|
var offsetY4Bottom = popupMirrorRect.bottom - popupRect.y - (nextOffsetY + popupRect.height);
|
|
setOffsetInfo({
|
|
ready: true,
|
|
offsetX: nextOffsetX / _scaleX,
|
|
offsetY: nextOffsetY / _scaleY,
|
|
offsetR: offsetX4Right / _scaleX,
|
|
offsetB: offsetY4Bottom / _scaleY,
|
|
arrowX: nextArrowX / _scaleX,
|
|
arrowY: nextArrowY / _scaleY,
|
|
scaleX: _scaleX,
|
|
scaleY: _scaleY,
|
|
align: nextAlignInfo
|
|
});
|
|
}
|
|
});
|
|
var triggerAlign = function triggerAlign() {
|
|
alignCountRef.current += 1;
|
|
var id = alignCountRef.current;
|
|
|
|
// Merge all align requirement into one frame
|
|
Promise.resolve().then(function () {
|
|
if (alignCountRef.current === id) {
|
|
onAlign();
|
|
}
|
|
});
|
|
};
|
|
|
|
// Reset ready status when placement & open changed
|
|
var resetReady = function resetReady() {
|
|
setOffsetInfo(function (ori) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, ori), {}, {
|
|
ready: false
|
|
});
|
|
});
|
|
};
|
|
hooks_useLayoutEffect(resetReady, [placement]);
|
|
hooks_useLayoutEffect(function () {
|
|
if (!open) {
|
|
resetReady();
|
|
}
|
|
}, [open]);
|
|
return [offsetInfo.ready, offsetInfo.offsetX, offsetInfo.offsetY, offsetInfo.offsetR, offsetInfo.offsetB, offsetInfo.arrowX, offsetInfo.arrowY, offsetInfo.scaleX, offsetInfo.scaleY, offsetInfo.align, triggerAlign];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/hooks/useWatch.js
|
|
|
|
|
|
|
|
function useWatch(open, target, popup, onAlign) {
|
|
hooks_useLayoutEffect(function () {
|
|
if (open && target && popup) {
|
|
var targetElement = target;
|
|
var popupElement = popup;
|
|
var targetScrollList = collectScroller(targetElement);
|
|
var popupScrollList = collectScroller(popupElement);
|
|
var win = getWin(popupElement);
|
|
var mergedList = new Set([win].concat((0,toConsumableArray/* default */.Z)(targetScrollList), (0,toConsumableArray/* default */.Z)(popupScrollList)));
|
|
function notifyScroll() {
|
|
onAlign();
|
|
}
|
|
mergedList.forEach(function (scroller) {
|
|
scroller.addEventListener('scroll', notifyScroll, {
|
|
passive: true
|
|
});
|
|
});
|
|
win.addEventListener('resize', notifyScroll, {
|
|
passive: true
|
|
});
|
|
|
|
// First time always do align
|
|
onAlign();
|
|
return function () {
|
|
mergedList.forEach(function (scroller) {
|
|
scroller.removeEventListener('scroll', notifyScroll);
|
|
win.removeEventListener('resize', notifyScroll);
|
|
});
|
|
};
|
|
}
|
|
}, [open, target, popup]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/utils/set.js
|
|
|
|
|
|
|
|
|
|
|
|
function internalSet(entity, paths, value, removeIfUndefined) {
|
|
if (!paths.length) {
|
|
return value;
|
|
}
|
|
var _paths = _toArray(paths),
|
|
path = _paths[0],
|
|
restPath = _paths.slice(1);
|
|
var clone;
|
|
if (!entity && typeof path === 'number') {
|
|
clone = [];
|
|
} else if (Array.isArray(entity)) {
|
|
clone = _toConsumableArray(entity);
|
|
} else {
|
|
clone = _objectSpread({}, entity);
|
|
}
|
|
|
|
// Delete prop if `removeIfUndefined` and value is undefined
|
|
if (removeIfUndefined && value === undefined && restPath.length === 1) {
|
|
delete clone[path][restPath[0]];
|
|
} else {
|
|
clone[path] = internalSet(clone[path], restPath, value, removeIfUndefined);
|
|
}
|
|
return clone;
|
|
}
|
|
function set(entity, paths, value) {
|
|
var removeIfUndefined = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
// Do nothing if `removeIfUndefined` and parent object not exist
|
|
if (paths.length && removeIfUndefined && value === undefined && !get(entity, paths.slice(0, -1))) {
|
|
return entity;
|
|
}
|
|
return internalSet(entity, paths, value, removeIfUndefined);
|
|
}
|
|
function isObject(obj) {
|
|
return _typeof(obj) === 'object' && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
|
|
}
|
|
function createEmpty(source) {
|
|
return Array.isArray(source) ? [] : {};
|
|
}
|
|
var keys = typeof Reflect === 'undefined' ? Object.keys : Reflect.ownKeys;
|
|
|
|
/**
|
|
* Merge objects which will create
|
|
*/
|
|
function merge() {
|
|
for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
sources[_key] = arguments[_key];
|
|
}
|
|
var clone = createEmpty(sources[0]);
|
|
sources.forEach(function (src) {
|
|
function internalMerge(path, parentLoopSet) {
|
|
var loopSet = new Set(parentLoopSet);
|
|
var value = get(src, path);
|
|
var isArr = Array.isArray(value);
|
|
if (isArr || isObject(value)) {
|
|
// Only add not loop obj
|
|
if (!loopSet.has(value)) {
|
|
loopSet.add(value);
|
|
var originValue = get(clone, path);
|
|
if (isArr) {
|
|
// Array will always be override
|
|
clone = set(clone, path, []);
|
|
} else if (!originValue || _typeof(originValue) !== 'object') {
|
|
// Init container if not exist
|
|
clone = set(clone, path, createEmpty(value));
|
|
}
|
|
keys(value).forEach(function (key) {
|
|
internalMerge([].concat(_toConsumableArray(path), [key]), loopSet);
|
|
});
|
|
}
|
|
} else {
|
|
clone = set(clone, path, value);
|
|
}
|
|
}
|
|
internalMerge([]);
|
|
});
|
|
return clone;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/index.js
|
|
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/hooks/useWinClick.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useWinClick(open, clickToHide, targetEle, popupEle, mask, maskClosable, inPopupOrChild, triggerOpen) {
|
|
var openRef = react.useRef(open);
|
|
|
|
// Window click to hide should be lock to avoid trigger lock immediately
|
|
var lockRef = react.useRef(false);
|
|
if (openRef.current !== open) {
|
|
lockRef.current = true;
|
|
openRef.current = open;
|
|
}
|
|
react.useEffect(function () {
|
|
var id = es_raf(function () {
|
|
lockRef.current = false;
|
|
});
|
|
return function () {
|
|
es_raf.cancel(id);
|
|
};
|
|
}, [open]);
|
|
|
|
// Click to hide is special action since click popup element should not hide
|
|
react.useEffect(function () {
|
|
if (clickToHide && popupEle && (!mask || maskClosable)) {
|
|
var genClickEvents = function genClickEvents() {
|
|
var clickInside = false;
|
|
|
|
// User may mouseDown inside and drag out of popup and mouse up
|
|
// Record here to prevent close
|
|
var onWindowMouseDown = function onWindowMouseDown(_ref) {
|
|
var target = _ref.target;
|
|
clickInside = inPopupOrChild(target);
|
|
};
|
|
var onWindowClick = function onWindowClick(_ref2) {
|
|
var target = _ref2.target;
|
|
if (!lockRef.current && openRef.current && !clickInside && !inPopupOrChild(target)) {
|
|
triggerOpen(false);
|
|
}
|
|
};
|
|
return [onWindowMouseDown, onWindowClick];
|
|
};
|
|
|
|
// Events
|
|
var _genClickEvents = genClickEvents(),
|
|
_genClickEvents2 = (0,slicedToArray/* default */.Z)(_genClickEvents, 2),
|
|
onWinMouseDown = _genClickEvents2[0],
|
|
onWinClick = _genClickEvents2[1];
|
|
var _genClickEvents3 = genClickEvents(),
|
|
_genClickEvents4 = (0,slicedToArray/* default */.Z)(_genClickEvents3, 2),
|
|
onShadowMouseDown = _genClickEvents4[0],
|
|
onShadowClick = _genClickEvents4[1];
|
|
var win = getWin(popupEle);
|
|
win.addEventListener('mousedown', onWinMouseDown);
|
|
win.addEventListener('click', onWinClick);
|
|
win.addEventListener('contextmenu', onWinClick);
|
|
|
|
// shadow root
|
|
var targetShadowRoot = getShadowRoot(targetEle);
|
|
if (targetShadowRoot) {
|
|
targetShadowRoot.addEventListener('mousedown', onShadowMouseDown);
|
|
targetShadowRoot.addEventListener('click', onShadowClick);
|
|
targetShadowRoot.addEventListener('contextmenu', onShadowClick);
|
|
}
|
|
|
|
// Warning if target and popup not in same root
|
|
if (false) { var popupRoot, targetRoot, _targetEle$getRootNod, _popupEle$getRootNode; }
|
|
return function () {
|
|
win.removeEventListener('mousedown', onWinMouseDown);
|
|
win.removeEventListener('click', onWinClick);
|
|
win.removeEventListener('contextmenu', onWinClick);
|
|
if (targetShadowRoot) {
|
|
targetShadowRoot.removeEventListener('mousedown', onShadowMouseDown);
|
|
targetShadowRoot.removeEventListener('click', onShadowClick);
|
|
targetShadowRoot.removeEventListener('contextmenu', onShadowClick);
|
|
}
|
|
};
|
|
}
|
|
}, [clickToHide, targetEle, popupEle, mask, maskClosable]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/node_modules/rc-util/es/Dom/findDOMNode.js
|
|
|
|
|
|
function findDOMNode_isDOM(node) {
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element
|
|
// Since XULElement is also subclass of Element, we only need HTMLElement and SVGElement
|
|
return node instanceof HTMLElement || node instanceof SVGElement;
|
|
}
|
|
|
|
/**
|
|
* Return if a node is a DOM node. Else will return by `findDOMNode`
|
|
*/
|
|
function findDOMNode_findDOMNode(node) {
|
|
if (findDOMNode_isDOM(node)) {
|
|
return node;
|
|
}
|
|
if (node instanceof react.Component) {
|
|
return react_dom.findDOMNode(node);
|
|
}
|
|
return null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/node_modules/rc-util/es/hooks/useMemo.js
|
|
|
|
function es_hooks_useMemo_useMemo(getValue, condition, shouldUpdate) {
|
|
var cacheRef = React.useRef({});
|
|
if (!('value' in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
|
|
cacheRef.current.value = getValue();
|
|
cacheRef.current.condition = condition;
|
|
}
|
|
return cacheRef.current.value;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/node_modules/rc-util/es/ref.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
|
|
function ref_fillRef(ref, node) {
|
|
if (typeof ref === 'function') {
|
|
ref(node);
|
|
} else if ((0,esm_typeof/* default */.Z)(ref) === 'object' && ref && 'current' in ref) {
|
|
ref.current = node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge refs into one ref function to support ref passing.
|
|
*/
|
|
function ref_composeRef() {
|
|
for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
refs[_key] = arguments[_key];
|
|
}
|
|
var refList = refs.filter(function (ref) {
|
|
return ref;
|
|
});
|
|
if (refList.length <= 1) {
|
|
return refList[0];
|
|
}
|
|
return function (node) {
|
|
refs.forEach(function (ref) {
|
|
ref_fillRef(ref, node);
|
|
});
|
|
};
|
|
}
|
|
function ref_useComposeRef() {
|
|
for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
refs[_key2] = arguments[_key2];
|
|
}
|
|
return useMemo(function () {
|
|
return ref_composeRef.apply(void 0, refs);
|
|
}, refs, function (prev, next) {
|
|
return prev.length === next.length && prev.every(function (ref, i) {
|
|
return ref === next[i];
|
|
});
|
|
});
|
|
}
|
|
function ref_supportRef(nodeOrComponent) {
|
|
var _type$prototype, _nodeOrComponent$prot;
|
|
var type = (0,react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
|
|
|
|
// Function component node
|
|
if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
|
|
return false;
|
|
}
|
|
|
|
// Class component
|
|
if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/node_modules/rc-util/es/Dom/canUseDom.js
|
|
function Dom_canUseDom_canUseDom() {
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/util/motion.js
|
|
|
|
|
|
|
|
// ================= Transition =================
|
|
// Event wrapper. Copy from react source code
|
|
function makePrefixMap(styleProp, eventName) {
|
|
var prefixes = {};
|
|
prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
|
|
prefixes["Webkit".concat(styleProp)] = "webkit".concat(eventName);
|
|
prefixes["Moz".concat(styleProp)] = "moz".concat(eventName);
|
|
prefixes["ms".concat(styleProp)] = "MS".concat(eventName);
|
|
prefixes["O".concat(styleProp)] = "o".concat(eventName.toLowerCase());
|
|
return prefixes;
|
|
}
|
|
|
|
function getVendorPrefixes(domSupport, win) {
|
|
var prefixes = {
|
|
animationend: makePrefixMap('Animation', 'AnimationEnd'),
|
|
transitionend: makePrefixMap('Transition', 'TransitionEnd')
|
|
};
|
|
|
|
if (domSupport) {
|
|
if (!('AnimationEvent' in win)) {
|
|
delete prefixes.animationend.animation;
|
|
}
|
|
|
|
if (!('TransitionEvent' in win)) {
|
|
delete prefixes.transitionend.transition;
|
|
}
|
|
}
|
|
|
|
return prefixes;
|
|
}
|
|
var vendorPrefixes = getVendorPrefixes(Dom_canUseDom_canUseDom(), typeof window !== 'undefined' ? window : {});
|
|
var style = {};
|
|
|
|
if (Dom_canUseDom_canUseDom()) {
|
|
var _document$createEleme = document.createElement('div');
|
|
|
|
style = _document$createEleme.style;
|
|
}
|
|
|
|
var prefixedEventNames = {};
|
|
function getVendorPrefixedEventName(eventName) {
|
|
if (prefixedEventNames[eventName]) {
|
|
return prefixedEventNames[eventName];
|
|
}
|
|
|
|
var prefixMap = vendorPrefixes[eventName];
|
|
|
|
if (prefixMap) {
|
|
var stylePropList = Object.keys(prefixMap);
|
|
var len = stylePropList.length;
|
|
|
|
for (var i = 0; i < len; i += 1) {
|
|
var styleProp = stylePropList[i];
|
|
|
|
if (Object.prototype.hasOwnProperty.call(prefixMap, styleProp) && styleProp in style) {
|
|
prefixedEventNames[eventName] = prefixMap[styleProp];
|
|
return prefixedEventNames[eventName];
|
|
}
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
var internalAnimationEndName = getVendorPrefixedEventName('animationend');
|
|
var internalTransitionEndName = getVendorPrefixedEventName('transitionend');
|
|
var supportTransition = !!(internalAnimationEndName && internalTransitionEndName);
|
|
var animationEndName = internalAnimationEndName || 'animationend';
|
|
var transitionEndName = internalTransitionEndName || 'transitionend';
|
|
function getTransitionName(transitionName, transitionType) {
|
|
if (!transitionName) return null;
|
|
|
|
if ((0,esm_typeof/* default */.Z)(transitionName) === 'object') {
|
|
var type = transitionType.replace(/-\w/g, function (match) {
|
|
return match[1].toUpperCase();
|
|
});
|
|
return transitionName[type];
|
|
}
|
|
|
|
return "".concat(transitionName, "-").concat(transitionType);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/interface.js
|
|
var STATUS_NONE = 'none';
|
|
var STATUS_APPEAR = 'appear';
|
|
var STATUS_ENTER = 'enter';
|
|
var STATUS_LEAVE = 'leave';
|
|
var STEP_NONE = 'none';
|
|
var STEP_PREPARE = 'prepare';
|
|
var STEP_START = 'start';
|
|
var STEP_ACTIVE = 'active';
|
|
var STEP_ACTIVATED = 'end';
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/node_modules/rc-util/es/hooks/useState.js
|
|
|
|
|
|
/**
|
|
* Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed.
|
|
* We do not make this auto is to avoid real memory leak.
|
|
* Developer should confirm it's safe to ignore themselves.
|
|
*/
|
|
function useState_useSafeState(defaultValue) {
|
|
var destroyRef = react.useRef(false);
|
|
var _React$useState = react.useState(defaultValue),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
value = _React$useState2[0],
|
|
setValue = _React$useState2[1];
|
|
react.useEffect(function () {
|
|
destroyRef.current = false;
|
|
return function () {
|
|
destroyRef.current = true;
|
|
};
|
|
}, []);
|
|
function safeSetState(updater, ignoreDestroy) {
|
|
if (ignoreDestroy && destroyRef.current) {
|
|
return;
|
|
}
|
|
setValue(updater);
|
|
}
|
|
return [value, safeSetState];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/node_modules/rc-util/es/raf.js
|
|
var raf_raf = function raf(callback) {
|
|
return +setTimeout(callback, 16);
|
|
};
|
|
var raf_caf = function caf(num) {
|
|
return clearTimeout(num);
|
|
};
|
|
if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
|
|
raf_raf = function raf(callback) {
|
|
return window.requestAnimationFrame(callback);
|
|
};
|
|
raf_caf = function caf(handle) {
|
|
return window.cancelAnimationFrame(handle);
|
|
};
|
|
}
|
|
var raf_rafUUID = 0;
|
|
var raf_rafIds = new Map();
|
|
function raf_cleanup(id) {
|
|
raf_rafIds.delete(id);
|
|
}
|
|
var raf_wrapperRaf = function wrapperRaf(callback) {
|
|
var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
raf_rafUUID += 1;
|
|
var id = raf_rafUUID;
|
|
function callRef(leftTimes) {
|
|
if (leftTimes === 0) {
|
|
// Clean up
|
|
raf_cleanup(id);
|
|
|
|
// Trigger
|
|
callback();
|
|
} else {
|
|
// Next raf
|
|
var realId = raf_raf(function () {
|
|
callRef(leftTimes - 1);
|
|
});
|
|
|
|
// Bind real raf id
|
|
raf_rafIds.set(id, realId);
|
|
}
|
|
}
|
|
callRef(times);
|
|
return id;
|
|
};
|
|
raf_wrapperRaf.cancel = function (id) {
|
|
var realId = raf_rafIds.get(id);
|
|
raf_cleanup(realId);
|
|
return raf_caf(realId);
|
|
};
|
|
/* harmony default export */ var rc_util_es_raf = (raf_wrapperRaf);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/hooks/useNextFrame.js
|
|
|
|
|
|
/* harmony default export */ var useNextFrame = (function () {
|
|
var nextFrameRef = react.useRef(null);
|
|
|
|
function cancelNextFrame() {
|
|
rc_util_es_raf.cancel(nextFrameRef.current);
|
|
}
|
|
|
|
function nextFrame(callback) {
|
|
var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
|
|
cancelNextFrame();
|
|
var nextFrameId = rc_util_es_raf(function () {
|
|
if (delay <= 1) {
|
|
callback({
|
|
isCanceled: function isCanceled() {
|
|
return nextFrameId !== nextFrameRef.current;
|
|
}
|
|
});
|
|
} else {
|
|
nextFrame(callback, delay - 1);
|
|
}
|
|
});
|
|
nextFrameRef.current = nextFrameId;
|
|
}
|
|
|
|
react.useEffect(function () {
|
|
return function () {
|
|
cancelNextFrame();
|
|
};
|
|
}, []);
|
|
return [nextFrame, cancelNextFrame];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/hooks/useIsomorphicLayoutEffect.js
|
|
|
|
// It's safe to use `useLayoutEffect` but the warning is annoying
|
|
|
|
var useIsomorphicLayoutEffect = Dom_canUseDom_canUseDom() ? react.useLayoutEffect : react.useEffect;
|
|
/* harmony default export */ var hooks_useIsomorphicLayoutEffect = (useIsomorphicLayoutEffect);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/hooks/useStepQueue.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var STEP_QUEUE = [STEP_PREPARE, STEP_START, STEP_ACTIVE, STEP_ACTIVATED];
|
|
/** Skip current step */
|
|
|
|
var SkipStep = false;
|
|
/** Current step should be update in */
|
|
|
|
var DoStep = true;
|
|
function isActive(step) {
|
|
return step === STEP_ACTIVE || step === STEP_ACTIVATED;
|
|
}
|
|
/* harmony default export */ var useStepQueue = (function (status, callback) {
|
|
var _useState = useState_useSafeState(STEP_NONE),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
step = _useState2[0],
|
|
setStep = _useState2[1];
|
|
|
|
var _useNextFrame = useNextFrame(),
|
|
_useNextFrame2 = (0,slicedToArray/* default */.Z)(_useNextFrame, 2),
|
|
nextFrame = _useNextFrame2[0],
|
|
cancelNextFrame = _useNextFrame2[1];
|
|
|
|
function startQueue() {
|
|
setStep(STEP_PREPARE, true);
|
|
}
|
|
|
|
hooks_useIsomorphicLayoutEffect(function () {
|
|
if (step !== STEP_NONE && step !== STEP_ACTIVATED) {
|
|
var index = STEP_QUEUE.indexOf(step);
|
|
var nextStep = STEP_QUEUE[index + 1];
|
|
var result = callback(step);
|
|
|
|
if (result === SkipStep) {
|
|
// Skip when no needed
|
|
setStep(nextStep, true);
|
|
} else {
|
|
// Do as frame for step update
|
|
nextFrame(function (info) {
|
|
function doNext() {
|
|
// Skip since current queue is ood
|
|
if (info.isCanceled()) return;
|
|
setStep(nextStep, true);
|
|
}
|
|
|
|
if (result === true) {
|
|
doNext();
|
|
} else {
|
|
// Only promise should be async
|
|
Promise.resolve(result).then(doNext);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, [status, step]);
|
|
react.useEffect(function () {
|
|
return function () {
|
|
cancelNextFrame();
|
|
};
|
|
}, []);
|
|
return [startQueue, step];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/hooks/useDomMotionEvents.js
|
|
|
|
|
|
|
|
/* harmony default export */ var useDomMotionEvents = (function (callback) {
|
|
var cacheElementRef = (0,react.useRef)(); // Cache callback
|
|
|
|
var callbackRef = (0,react.useRef)(callback);
|
|
callbackRef.current = callback; // Internal motion event handler
|
|
|
|
var onInternalMotionEnd = react.useCallback(function (event) {
|
|
callbackRef.current(event);
|
|
}, []); // Remove events
|
|
|
|
function removeMotionEvents(element) {
|
|
if (element) {
|
|
element.removeEventListener(transitionEndName, onInternalMotionEnd);
|
|
element.removeEventListener(animationEndName, onInternalMotionEnd);
|
|
}
|
|
} // Patch events
|
|
|
|
|
|
function patchMotionEvents(element) {
|
|
if (cacheElementRef.current && cacheElementRef.current !== element) {
|
|
removeMotionEvents(cacheElementRef.current);
|
|
}
|
|
|
|
if (element && element !== cacheElementRef.current) {
|
|
element.addEventListener(transitionEndName, onInternalMotionEnd);
|
|
element.addEventListener(animationEndName, onInternalMotionEnd); // Save as cache in case dom removed trigger by `motionDeadline`
|
|
|
|
cacheElementRef.current = element;
|
|
}
|
|
} // Clean up when removed
|
|
|
|
|
|
react.useEffect(function () {
|
|
return function () {
|
|
removeMotionEvents(cacheElementRef.current);
|
|
};
|
|
}, []);
|
|
return [patchMotionEvents, removeMotionEvents];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/hooks/useStatus.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useStatus(supportMotion, visible, getElement, _ref) {
|
|
var _ref$motionEnter = _ref.motionEnter,
|
|
motionEnter = _ref$motionEnter === void 0 ? true : _ref$motionEnter,
|
|
_ref$motionAppear = _ref.motionAppear,
|
|
motionAppear = _ref$motionAppear === void 0 ? true : _ref$motionAppear,
|
|
_ref$motionLeave = _ref.motionLeave,
|
|
motionLeave = _ref$motionLeave === void 0 ? true : _ref$motionLeave,
|
|
motionDeadline = _ref.motionDeadline,
|
|
motionLeaveImmediately = _ref.motionLeaveImmediately,
|
|
onAppearPrepare = _ref.onAppearPrepare,
|
|
onEnterPrepare = _ref.onEnterPrepare,
|
|
onLeavePrepare = _ref.onLeavePrepare,
|
|
onAppearStart = _ref.onAppearStart,
|
|
onEnterStart = _ref.onEnterStart,
|
|
onLeaveStart = _ref.onLeaveStart,
|
|
onAppearActive = _ref.onAppearActive,
|
|
onEnterActive = _ref.onEnterActive,
|
|
onLeaveActive = _ref.onLeaveActive,
|
|
onAppearEnd = _ref.onAppearEnd,
|
|
onEnterEnd = _ref.onEnterEnd,
|
|
onLeaveEnd = _ref.onLeaveEnd,
|
|
onVisibleChanged = _ref.onVisibleChanged;
|
|
|
|
// Used for outer render usage to avoid `visible: false & status: none` to render nothing
|
|
var _useState = useState_useSafeState(),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
asyncVisible = _useState2[0],
|
|
setAsyncVisible = _useState2[1];
|
|
|
|
var _useState3 = useState_useSafeState(STATUS_NONE),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
status = _useState4[0],
|
|
setStatus = _useState4[1];
|
|
|
|
var _useState5 = useState_useSafeState(null),
|
|
_useState6 = (0,slicedToArray/* default */.Z)(_useState5, 2),
|
|
style = _useState6[0],
|
|
setStyle = _useState6[1];
|
|
|
|
var mountedRef = (0,react.useRef)(false);
|
|
var deadlineRef = (0,react.useRef)(null); // =========================== Dom Node ===========================
|
|
|
|
function getDomElement() {
|
|
return getElement();
|
|
} // ========================== Motion End ==========================
|
|
|
|
|
|
var activeRef = (0,react.useRef)(false);
|
|
|
|
function onInternalMotionEnd(event) {
|
|
var element = getDomElement();
|
|
|
|
if (event && !event.deadline && event.target !== element) {
|
|
// event exists
|
|
// not initiated by deadline
|
|
// transitionEnd not fired by inner elements
|
|
return;
|
|
}
|
|
|
|
var currentActive = activeRef.current;
|
|
var canEnd;
|
|
|
|
if (status === STATUS_APPEAR && currentActive) {
|
|
canEnd = onAppearEnd === null || onAppearEnd === void 0 ? void 0 : onAppearEnd(element, event);
|
|
} else if (status === STATUS_ENTER && currentActive) {
|
|
canEnd = onEnterEnd === null || onEnterEnd === void 0 ? void 0 : onEnterEnd(element, event);
|
|
} else if (status === STATUS_LEAVE && currentActive) {
|
|
canEnd = onLeaveEnd === null || onLeaveEnd === void 0 ? void 0 : onLeaveEnd(element, event);
|
|
} // Only update status when `canEnd` and not destroyed
|
|
|
|
|
|
if (status !== STATUS_NONE && currentActive && canEnd !== false) {
|
|
setStatus(STATUS_NONE, true);
|
|
setStyle(null, true);
|
|
}
|
|
}
|
|
|
|
var _useDomMotionEvents = useDomMotionEvents(onInternalMotionEnd),
|
|
_useDomMotionEvents2 = (0,slicedToArray/* default */.Z)(_useDomMotionEvents, 1),
|
|
patchMotionEvents = _useDomMotionEvents2[0]; // ============================= Step =============================
|
|
|
|
|
|
var eventHandlers = react.useMemo(function () {
|
|
var _ref2, _ref3, _ref4;
|
|
|
|
switch (status) {
|
|
case STATUS_APPEAR:
|
|
return _ref2 = {}, (0,defineProperty/* default */.Z)(_ref2, STEP_PREPARE, onAppearPrepare), (0,defineProperty/* default */.Z)(_ref2, STEP_START, onAppearStart), (0,defineProperty/* default */.Z)(_ref2, STEP_ACTIVE, onAppearActive), _ref2;
|
|
|
|
case STATUS_ENTER:
|
|
return _ref3 = {}, (0,defineProperty/* default */.Z)(_ref3, STEP_PREPARE, onEnterPrepare), (0,defineProperty/* default */.Z)(_ref3, STEP_START, onEnterStart), (0,defineProperty/* default */.Z)(_ref3, STEP_ACTIVE, onEnterActive), _ref3;
|
|
|
|
case STATUS_LEAVE:
|
|
return _ref4 = {}, (0,defineProperty/* default */.Z)(_ref4, STEP_PREPARE, onLeavePrepare), (0,defineProperty/* default */.Z)(_ref4, STEP_START, onLeaveStart), (0,defineProperty/* default */.Z)(_ref4, STEP_ACTIVE, onLeaveActive), _ref4;
|
|
|
|
default:
|
|
return {};
|
|
}
|
|
}, [status]);
|
|
|
|
var _useStepQueue = useStepQueue(status, function (newStep) {
|
|
// Only prepare step can be skip
|
|
if (newStep === STEP_PREPARE) {
|
|
var onPrepare = eventHandlers[STEP_PREPARE];
|
|
|
|
if (!onPrepare) {
|
|
return SkipStep;
|
|
}
|
|
|
|
return onPrepare(getDomElement());
|
|
} // Rest step is sync update
|
|
|
|
|
|
if (step in eventHandlers) {
|
|
var _eventHandlers$step;
|
|
|
|
setStyle(((_eventHandlers$step = eventHandlers[step]) === null || _eventHandlers$step === void 0 ? void 0 : _eventHandlers$step.call(eventHandlers, getDomElement(), null)) || null);
|
|
}
|
|
|
|
if (step === STEP_ACTIVE) {
|
|
// Patch events when motion needed
|
|
patchMotionEvents(getDomElement());
|
|
|
|
if (motionDeadline > 0) {
|
|
clearTimeout(deadlineRef.current);
|
|
deadlineRef.current = setTimeout(function () {
|
|
onInternalMotionEnd({
|
|
deadline: true
|
|
});
|
|
}, motionDeadline);
|
|
}
|
|
}
|
|
|
|
return DoStep;
|
|
}),
|
|
_useStepQueue2 = (0,slicedToArray/* default */.Z)(_useStepQueue, 2),
|
|
startStep = _useStepQueue2[0],
|
|
step = _useStepQueue2[1];
|
|
|
|
var active = isActive(step);
|
|
activeRef.current = active; // ============================ Status ============================
|
|
// Update with new status
|
|
|
|
hooks_useIsomorphicLayoutEffect(function () {
|
|
setAsyncVisible(visible);
|
|
var isMounted = mountedRef.current;
|
|
mountedRef.current = true;
|
|
|
|
if (!supportMotion) {
|
|
return;
|
|
}
|
|
|
|
var nextStatus; // Appear
|
|
|
|
if (!isMounted && visible && motionAppear) {
|
|
nextStatus = STATUS_APPEAR;
|
|
} // Enter
|
|
|
|
|
|
if (isMounted && visible && motionEnter) {
|
|
nextStatus = STATUS_ENTER;
|
|
} // Leave
|
|
|
|
|
|
if (isMounted && !visible && motionLeave || !isMounted && motionLeaveImmediately && !visible && motionLeave) {
|
|
nextStatus = STATUS_LEAVE;
|
|
} // Update to next status
|
|
|
|
|
|
if (nextStatus) {
|
|
setStatus(nextStatus);
|
|
startStep();
|
|
}
|
|
}, [visible]); // ============================ Effect ============================
|
|
// Reset when motion changed
|
|
|
|
(0,react.useEffect)(function () {
|
|
if ( // Cancel appear
|
|
status === STATUS_APPEAR && !motionAppear || // Cancel enter
|
|
status === STATUS_ENTER && !motionEnter || // Cancel leave
|
|
status === STATUS_LEAVE && !motionLeave) {
|
|
setStatus(STATUS_NONE);
|
|
}
|
|
}, [motionAppear, motionEnter, motionLeave]);
|
|
(0,react.useEffect)(function () {
|
|
return function () {
|
|
mountedRef.current = false;
|
|
clearTimeout(deadlineRef.current);
|
|
};
|
|
}, []); // Trigger `onVisibleChanged`
|
|
|
|
var firstMountChangeRef = react.useRef(false);
|
|
(0,react.useEffect)(function () {
|
|
// [visible & motion not end] => [!visible & motion end] still need trigger onVisibleChanged
|
|
if (asyncVisible) {
|
|
firstMountChangeRef.current = true;
|
|
}
|
|
|
|
if (asyncVisible !== undefined && status === STATUS_NONE) {
|
|
// Skip first render is invisible since it's nothing changed
|
|
if (firstMountChangeRef.current || asyncVisible) {
|
|
onVisibleChanged === null || onVisibleChanged === void 0 ? void 0 : onVisibleChanged(asyncVisible);
|
|
}
|
|
|
|
firstMountChangeRef.current = true;
|
|
}
|
|
}, [asyncVisible, status]); // ============================ Styles ============================
|
|
|
|
var mergedStyle = style;
|
|
|
|
if (eventHandlers[STEP_PREPARE] && step === STEP_START) {
|
|
mergedStyle = (0,objectSpread2/* default */.Z)({
|
|
transition: 'none'
|
|
}, mergedStyle);
|
|
}
|
|
|
|
return [status, step, mergedStyle, asyncVisible !== null && asyncVisible !== void 0 ? asyncVisible : visible];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/DomWrapper.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var DomWrapper = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(DomWrapper, _React$Component);
|
|
|
|
var _super = (0,createSuper/* default */.Z)(DomWrapper);
|
|
|
|
function DomWrapper() {
|
|
(0,classCallCheck/* default */.Z)(this, DomWrapper);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
(0,createClass/* default */.Z)(DomWrapper, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return this.props.children;
|
|
}
|
|
}]);
|
|
|
|
return DomWrapper;
|
|
}(react.Component);
|
|
|
|
/* harmony default export */ var es_DomWrapper = (DomWrapper);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/CSSMotion.js
|
|
|
|
|
|
|
|
|
|
|
|
/* eslint-disable react/default-props-match-prop-types, react/no-multi-comp, react/prop-types */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* `transitionSupport` is used for none transition test case.
|
|
* Default we use browser transition event support check.
|
|
*/
|
|
function genCSSMotion(config) {
|
|
var transitionSupport = config;
|
|
|
|
if ((0,esm_typeof/* default */.Z)(config) === 'object') {
|
|
transitionSupport = config.transitionSupport;
|
|
}
|
|
|
|
function isSupportTransition(props) {
|
|
return !!(props.motionName && transitionSupport);
|
|
}
|
|
|
|
var CSSMotion = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _props$visible = props.visible,
|
|
visible = _props$visible === void 0 ? true : _props$visible,
|
|
_props$removeOnLeave = props.removeOnLeave,
|
|
removeOnLeave = _props$removeOnLeave === void 0 ? true : _props$removeOnLeave,
|
|
forceRender = props.forceRender,
|
|
children = props.children,
|
|
motionName = props.motionName,
|
|
leavedClassName = props.leavedClassName,
|
|
eventProps = props.eventProps;
|
|
var supportMotion = isSupportTransition(props); // Ref to the react node, it may be a HTMLElement
|
|
|
|
var nodeRef = (0,react.useRef)(); // Ref to the dom wrapper in case ref can not pass to HTMLElement
|
|
|
|
var wrapperNodeRef = (0,react.useRef)();
|
|
|
|
function getDomElement() {
|
|
try {
|
|
// Here we're avoiding call for findDOMNode since it's deprecated
|
|
// in strict mode. We're calling it only when node ref is not
|
|
// an instance of DOM HTMLElement. Otherwise use
|
|
// findDOMNode as a final resort
|
|
return nodeRef.current instanceof HTMLElement ? nodeRef.current : findDOMNode_findDOMNode(wrapperNodeRef.current);
|
|
} catch (e) {
|
|
// Only happen when `motionDeadline` trigger but element removed.
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var _useStatus = useStatus(supportMotion, visible, getDomElement, props),
|
|
_useStatus2 = (0,slicedToArray/* default */.Z)(_useStatus, 4),
|
|
status = _useStatus2[0],
|
|
statusStep = _useStatus2[1],
|
|
statusStyle = _useStatus2[2],
|
|
mergedVisible = _useStatus2[3]; // Record whether content has rendered
|
|
// Will return null for un-rendered even when `removeOnLeave={false}`
|
|
|
|
|
|
var renderedRef = react.useRef(mergedVisible);
|
|
|
|
if (mergedVisible) {
|
|
renderedRef.current = true;
|
|
} // ====================== Refs ======================
|
|
|
|
|
|
var setNodeRef = react.useCallback(function (node) {
|
|
nodeRef.current = node;
|
|
ref_fillRef(ref, node);
|
|
}, [ref]); // ===================== Render =====================
|
|
|
|
var motionChildren;
|
|
|
|
var mergedProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, eventProps), {}, {
|
|
visible: visible
|
|
});
|
|
|
|
if (!children) {
|
|
// No children
|
|
motionChildren = null;
|
|
} else if (status === STATUS_NONE || !isSupportTransition(props)) {
|
|
// Stable children
|
|
if (mergedVisible) {
|
|
motionChildren = children((0,objectSpread2/* default */.Z)({}, mergedProps), setNodeRef);
|
|
} else if (!removeOnLeave && renderedRef.current && leavedClassName) {
|
|
motionChildren = children((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedProps), {}, {
|
|
className: leavedClassName
|
|
}), setNodeRef);
|
|
} else if (forceRender || !removeOnLeave && !leavedClassName) {
|
|
motionChildren = children((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedProps), {}, {
|
|
style: {
|
|
display: 'none'
|
|
}
|
|
}), setNodeRef);
|
|
} else {
|
|
motionChildren = null;
|
|
}
|
|
} else {
|
|
var _classNames;
|
|
|
|
// In motion
|
|
var statusSuffix;
|
|
|
|
if (statusStep === STEP_PREPARE) {
|
|
statusSuffix = 'prepare';
|
|
} else if (isActive(statusStep)) {
|
|
statusSuffix = 'active';
|
|
} else if (statusStep === STEP_START) {
|
|
statusSuffix = 'start';
|
|
}
|
|
|
|
motionChildren = children((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedProps), {}, {
|
|
className: classnames_default()(getTransitionName(motionName, status), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, getTransitionName(motionName, "".concat(status, "-").concat(statusSuffix)), statusSuffix), (0,defineProperty/* default */.Z)(_classNames, motionName, typeof motionName === 'string'), _classNames)),
|
|
style: statusStyle
|
|
}), setNodeRef);
|
|
} // Auto inject ref if child node not have `ref` props
|
|
|
|
|
|
if ( /*#__PURE__*/react.isValidElement(motionChildren) && ref_supportRef(motionChildren)) {
|
|
var _ref = motionChildren,
|
|
originNodeRef = _ref.ref;
|
|
|
|
if (!originNodeRef) {
|
|
motionChildren = /*#__PURE__*/react.cloneElement(motionChildren, {
|
|
ref: setNodeRef
|
|
});
|
|
}
|
|
}
|
|
|
|
return /*#__PURE__*/react.createElement(es_DomWrapper, {
|
|
ref: wrapperNodeRef
|
|
}, motionChildren);
|
|
});
|
|
CSSMotion.displayName = 'CSSMotion';
|
|
return CSSMotion;
|
|
}
|
|
/* harmony default export */ var es_CSSMotion = (genCSSMotion(supportTransition));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/util/diff.js
|
|
|
|
|
|
var STATUS_ADD = 'add';
|
|
var STATUS_KEEP = 'keep';
|
|
var STATUS_REMOVE = 'remove';
|
|
var STATUS_REMOVED = 'removed';
|
|
function wrapKeyToObject(key) {
|
|
var keyObj;
|
|
|
|
if (key && (0,esm_typeof/* default */.Z)(key) === 'object' && 'key' in key) {
|
|
keyObj = key;
|
|
} else {
|
|
keyObj = {
|
|
key: key
|
|
};
|
|
}
|
|
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, keyObj), {}, {
|
|
key: String(keyObj.key)
|
|
});
|
|
}
|
|
function parseKeys() {
|
|
var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
return keys.map(wrapKeyToObject);
|
|
}
|
|
function diffKeys() {
|
|
var prevKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
var currentKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
var list = [];
|
|
var currentIndex = 0;
|
|
var currentLen = currentKeys.length;
|
|
var prevKeyObjects = parseKeys(prevKeys);
|
|
var currentKeyObjects = parseKeys(currentKeys); // Check prev keys to insert or keep
|
|
|
|
prevKeyObjects.forEach(function (keyObj) {
|
|
var hit = false;
|
|
|
|
for (var i = currentIndex; i < currentLen; i += 1) {
|
|
var currentKeyObj = currentKeyObjects[i];
|
|
|
|
if (currentKeyObj.key === keyObj.key) {
|
|
// New added keys should add before current key
|
|
if (currentIndex < i) {
|
|
list = list.concat(currentKeyObjects.slice(currentIndex, i).map(function (obj) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, obj), {}, {
|
|
status: STATUS_ADD
|
|
});
|
|
}));
|
|
currentIndex = i;
|
|
}
|
|
|
|
list.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, currentKeyObj), {}, {
|
|
status: STATUS_KEEP
|
|
}));
|
|
currentIndex += 1;
|
|
hit = true;
|
|
break;
|
|
}
|
|
} // If not hit, it means key is removed
|
|
|
|
|
|
if (!hit) {
|
|
list.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, keyObj), {}, {
|
|
status: STATUS_REMOVE
|
|
}));
|
|
}
|
|
}); // Add rest to the list
|
|
|
|
if (currentIndex < currentLen) {
|
|
list = list.concat(currentKeyObjects.slice(currentIndex).map(function (obj) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, obj), {}, {
|
|
status: STATUS_ADD
|
|
});
|
|
}));
|
|
}
|
|
/**
|
|
* Merge same key when it remove and add again:
|
|
* [1 - add, 2 - keep, 1 - remove] -> [1 - keep, 2 - keep]
|
|
*/
|
|
|
|
|
|
var keys = {};
|
|
list.forEach(function (_ref) {
|
|
var key = _ref.key;
|
|
keys[key] = (keys[key] || 0) + 1;
|
|
});
|
|
var duplicatedKeys = Object.keys(keys).filter(function (key) {
|
|
return keys[key] > 1;
|
|
});
|
|
duplicatedKeys.forEach(function (matchKey) {
|
|
// Remove `STATUS_REMOVE` node.
|
|
list = list.filter(function (_ref2) {
|
|
var key = _ref2.key,
|
|
status = _ref2.status;
|
|
return key !== matchKey || status !== STATUS_REMOVE;
|
|
}); // Update `STATUS_ADD` to `STATUS_KEEP`
|
|
|
|
list.forEach(function (node) {
|
|
if (node.key === matchKey) {
|
|
// eslint-disable-next-line no-param-reassign
|
|
node.status = STATUS_KEEP;
|
|
}
|
|
});
|
|
});
|
|
return list;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/CSSMotionList.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["component", "children", "onVisibleChanged", "onAllRemoved"],
|
|
_excluded2 = ["status"];
|
|
|
|
/* eslint react/prop-types: 0 */
|
|
|
|
|
|
|
|
|
|
var MOTION_PROP_NAMES = ['eventProps', 'visible', 'children', 'motionName', 'motionAppear', 'motionEnter', 'motionLeave', 'motionLeaveImmediately', 'motionDeadline', 'removeOnLeave', 'leavedClassName', 'onAppearStart', 'onAppearActive', 'onAppearEnd', 'onEnterStart', 'onEnterActive', 'onEnterEnd', 'onLeaveStart', 'onLeaveActive', 'onLeaveEnd'];
|
|
|
|
/**
|
|
* Generate a CSSMotionList component with config
|
|
* @param transitionSupport No need since CSSMotionList no longer depends on transition support
|
|
* @param CSSMotion CSSMotion component
|
|
*/
|
|
function genCSSMotionList(transitionSupport) {
|
|
var CSSMotion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : es_CSSMotion;
|
|
|
|
var CSSMotionList = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(CSSMotionList, _React$Component);
|
|
|
|
var _super = (0,createSuper/* default */.Z)(CSSMotionList);
|
|
|
|
function CSSMotionList() {
|
|
var _this;
|
|
|
|
(0,classCallCheck/* default */.Z)(this, CSSMotionList);
|
|
|
|
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));
|
|
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "state", {
|
|
keyEntities: []
|
|
});
|
|
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "removeKey", function (removeKey) {
|
|
var keyEntities = _this.state.keyEntities;
|
|
var nextKeyEntities = keyEntities.map(function (entity) {
|
|
if (entity.key !== removeKey) return entity;
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, entity), {}, {
|
|
status: STATUS_REMOVED
|
|
});
|
|
});
|
|
|
|
_this.setState({
|
|
keyEntities: nextKeyEntities
|
|
});
|
|
|
|
return nextKeyEntities.filter(function (_ref) {
|
|
var status = _ref.status;
|
|
return status !== STATUS_REMOVED;
|
|
}).length;
|
|
});
|
|
|
|
return _this;
|
|
}
|
|
|
|
(0,createClass/* default */.Z)(CSSMotionList, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var keyEntities = this.state.keyEntities;
|
|
|
|
var _this$props = this.props,
|
|
component = _this$props.component,
|
|
children = _this$props.children,
|
|
_onVisibleChanged = _this$props.onVisibleChanged,
|
|
onAllRemoved = _this$props.onAllRemoved,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(_this$props, _excluded);
|
|
|
|
var Component = component || react.Fragment;
|
|
var motionProps = {};
|
|
MOTION_PROP_NAMES.forEach(function (prop) {
|
|
motionProps[prop] = restProps[prop];
|
|
delete restProps[prop];
|
|
});
|
|
delete restProps.keys;
|
|
return /*#__PURE__*/react.createElement(Component, restProps, keyEntities.map(function (_ref2) {
|
|
var status = _ref2.status,
|
|
eventProps = (0,objectWithoutProperties/* default */.Z)(_ref2, _excluded2);
|
|
|
|
var visible = status === STATUS_ADD || status === STATUS_KEEP;
|
|
return /*#__PURE__*/react.createElement(CSSMotion, (0,esm_extends/* default */.Z)({}, motionProps, {
|
|
key: eventProps.key,
|
|
visible: visible,
|
|
eventProps: eventProps,
|
|
onVisibleChanged: function onVisibleChanged(changedVisible) {
|
|
_onVisibleChanged === null || _onVisibleChanged === void 0 ? void 0 : _onVisibleChanged(changedVisible, {
|
|
key: eventProps.key
|
|
});
|
|
|
|
if (!changedVisible) {
|
|
var restKeysCount = _this2.removeKey(eventProps.key);
|
|
|
|
if (restKeysCount === 0 && onAllRemoved) {
|
|
onAllRemoved();
|
|
}
|
|
}
|
|
}
|
|
}), children);
|
|
}));
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(_ref3, _ref4) {
|
|
var keys = _ref3.keys;
|
|
var keyEntities = _ref4.keyEntities;
|
|
var parsedKeyObjects = parseKeys(keys);
|
|
var mixedKeyEntities = diffKeys(keyEntities, parsedKeyObjects);
|
|
return {
|
|
keyEntities: mixedKeyEntities.filter(function (entity) {
|
|
var prevEntity = keyEntities.find(function (_ref5) {
|
|
var key = _ref5.key;
|
|
return entity.key === key;
|
|
}); // Remove if already mark as removed
|
|
|
|
if (prevEntity && prevEntity.status === STATUS_REMOVED && entity.status === STATUS_REMOVE) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
})
|
|
};
|
|
} // ZombieJ: Return the count of rest keys. It's safe to refactor if need more info.
|
|
|
|
}]);
|
|
|
|
return CSSMotionList;
|
|
}(react.Component);
|
|
|
|
(0,defineProperty/* default */.Z)(CSSMotionList, "defaultProps", {
|
|
component: 'div'
|
|
});
|
|
|
|
return CSSMotionList;
|
|
}
|
|
/* harmony default export */ var CSSMotionList = (genCSSMotionList(supportTransition));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-motion/es/index.js
|
|
|
|
|
|
|
|
/* harmony default export */ var rc_motion_es = (es_CSSMotion);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/rc-util/es/ref.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
|
|
function es_ref_fillRef(ref, node) {
|
|
if (typeof ref === 'function') {
|
|
ref(node);
|
|
} else if ((0,esm_typeof/* default */.Z)(ref) === 'object' && ref && 'current' in ref) {
|
|
ref.current = node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge refs into one ref function to support ref passing.
|
|
*/
|
|
function es_ref_composeRef() {
|
|
for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
refs[_key] = arguments[_key];
|
|
}
|
|
var refList = refs.filter(function (ref) {
|
|
return ref;
|
|
});
|
|
if (refList.length <= 1) {
|
|
return refList[0];
|
|
}
|
|
return function (node) {
|
|
refs.forEach(function (ref) {
|
|
es_ref_fillRef(ref, node);
|
|
});
|
|
};
|
|
}
|
|
function es_ref_useComposeRef() {
|
|
for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
refs[_key2] = arguments[_key2];
|
|
}
|
|
return useMemo_useMemo(function () {
|
|
return es_ref_composeRef.apply(void 0, refs);
|
|
}, refs, function (prev, next) {
|
|
return prev.length === next.length && prev.every(function (ref, i) {
|
|
return ref === next[i];
|
|
});
|
|
});
|
|
}
|
|
function es_ref_supportRef(nodeOrComponent) {
|
|
var _type$prototype, _nodeOrComponent$prot;
|
|
var type = (0,react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
|
|
|
|
// Function component node
|
|
if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
|
|
return false;
|
|
}
|
|
|
|
// Class component
|
|
if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/Popup/Arrow.js
|
|
|
|
|
|
function Arrow(props) {
|
|
var prefixCls = props.prefixCls,
|
|
align = props.align,
|
|
arrow = props.arrow,
|
|
arrowPos = props.arrowPos;
|
|
var _ref = arrow || {},
|
|
className = _ref.className,
|
|
content = _ref.content;
|
|
var _arrowPos$x = arrowPos.x,
|
|
x = _arrowPos$x === void 0 ? 0 : _arrowPos$x,
|
|
_arrowPos$y = arrowPos.y,
|
|
y = _arrowPos$y === void 0 ? 0 : _arrowPos$y;
|
|
var arrowRef = react.useRef();
|
|
|
|
// Skip if no align
|
|
if (!align || !align.points) {
|
|
return null;
|
|
}
|
|
var alignStyle = {
|
|
position: 'absolute'
|
|
};
|
|
|
|
// Skip if no need to align
|
|
if (align.autoArrow !== false) {
|
|
var popupPoints = align.points[0];
|
|
var targetPoints = align.points[1];
|
|
var popupTB = popupPoints[0];
|
|
var popupLR = popupPoints[1];
|
|
var targetTB = targetPoints[0];
|
|
var targetLR = targetPoints[1];
|
|
|
|
// Top & Bottom
|
|
if (popupTB === targetTB || !['t', 'b'].includes(popupTB)) {
|
|
alignStyle.top = y;
|
|
} else if (popupTB === 't') {
|
|
alignStyle.top = 0;
|
|
} else {
|
|
alignStyle.bottom = 0;
|
|
}
|
|
|
|
// Left & Right
|
|
if (popupLR === targetLR || !['l', 'r'].includes(popupLR)) {
|
|
alignStyle.left = x;
|
|
} else if (popupLR === 'l') {
|
|
alignStyle.left = 0;
|
|
} else {
|
|
alignStyle.right = 0;
|
|
}
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: arrowRef,
|
|
className: classnames_default()("".concat(prefixCls, "-arrow"), className),
|
|
style: alignStyle
|
|
}, content);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/Popup/Mask.js
|
|
|
|
|
|
|
|
|
|
function Mask(props) {
|
|
var prefixCls = props.prefixCls,
|
|
open = props.open,
|
|
zIndex = props.zIndex,
|
|
mask = props.mask,
|
|
motion = props.motion;
|
|
if (!mask) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement(rc_motion_es, (0,esm_extends/* default */.Z)({}, motion, {
|
|
motionAppear: true,
|
|
visible: open,
|
|
removeOnLeave: true
|
|
}), function (_ref) {
|
|
var className = _ref.className;
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
style: {
|
|
zIndex: zIndex
|
|
},
|
|
className: classnames_default()("".concat(prefixCls, "-mask"), className)
|
|
});
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/Popup/PopupContent.js
|
|
|
|
var PopupContent = /*#__PURE__*/react.memo(function (_ref) {
|
|
var children = _ref.children;
|
|
return children;
|
|
}, function (_, next) {
|
|
return next.cache;
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var Popup_PopupContent = (PopupContent);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/Popup/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var Popup = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var popup = props.popup,
|
|
className = props.className,
|
|
prefixCls = props.prefixCls,
|
|
style = props.style,
|
|
target = props.target,
|
|
_onVisibleChanged = props.onVisibleChanged,
|
|
open = props.open,
|
|
keepDom = props.keepDom,
|
|
onClick = props.onClick,
|
|
mask = props.mask,
|
|
arrow = props.arrow,
|
|
arrowPos = props.arrowPos,
|
|
align = props.align,
|
|
motion = props.motion,
|
|
maskMotion = props.maskMotion,
|
|
forceRender = props.forceRender,
|
|
getPopupContainer = props.getPopupContainer,
|
|
autoDestroy = props.autoDestroy,
|
|
Portal = props.portal,
|
|
zIndex = props.zIndex,
|
|
onMouseEnter = props.onMouseEnter,
|
|
onMouseLeave = props.onMouseLeave,
|
|
ready = props.ready,
|
|
offsetX = props.offsetX,
|
|
offsetY = props.offsetY,
|
|
offsetR = props.offsetR,
|
|
offsetB = props.offsetB,
|
|
onAlign = props.onAlign,
|
|
onPrepare = props.onPrepare,
|
|
stretch = props.stretch,
|
|
targetWidth = props.targetWidth,
|
|
targetHeight = props.targetHeight;
|
|
var childNode = typeof popup === 'function' ? popup() : popup;
|
|
|
|
// We can not remove holder only when motion finished.
|
|
var isNodeVisible = open || keepDom;
|
|
|
|
// ======================= Container ========================
|
|
var getPopupContainerNeedParams = (getPopupContainer === null || getPopupContainer === void 0 ? void 0 : getPopupContainer.length) > 0;
|
|
var _React$useState = react.useState(!getPopupContainer || !getPopupContainerNeedParams),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
show = _React$useState2[0],
|
|
setShow = _React$useState2[1];
|
|
|
|
// Delay to show since `getPopupContainer` need target element
|
|
hooks_useLayoutEffect(function () {
|
|
if (!show && getPopupContainerNeedParams && target) {
|
|
setShow(true);
|
|
}
|
|
}, [show, getPopupContainerNeedParams, target]);
|
|
|
|
// ========================= Render =========================
|
|
if (!show) {
|
|
return null;
|
|
}
|
|
|
|
// >>>>> Offset
|
|
var AUTO = 'auto';
|
|
var offsetStyle = {
|
|
left: '-1000vw',
|
|
top: '-1000vh',
|
|
right: AUTO,
|
|
bottom: AUTO
|
|
};
|
|
|
|
// Set align style
|
|
if (ready || !open) {
|
|
var points = align.points,
|
|
_experimental = align._experimental;
|
|
var dynamicInset = _experimental === null || _experimental === void 0 ? void 0 : _experimental.dynamicInset;
|
|
var alignRight = dynamicInset && points[0][1] === 'r';
|
|
var alignBottom = dynamicInset && points[0][0] === 'b';
|
|
if (alignRight) {
|
|
offsetStyle.right = offsetR;
|
|
offsetStyle.left = AUTO;
|
|
} else {
|
|
offsetStyle.left = offsetX;
|
|
offsetStyle.right = AUTO;
|
|
}
|
|
if (alignBottom) {
|
|
offsetStyle.bottom = offsetB;
|
|
offsetStyle.top = AUTO;
|
|
} else {
|
|
offsetStyle.top = offsetY;
|
|
offsetStyle.bottom = AUTO;
|
|
}
|
|
}
|
|
|
|
// >>>>> Misc
|
|
var miscStyle = {};
|
|
if (stretch) {
|
|
if (stretch.includes('height') && targetHeight) {
|
|
miscStyle.height = targetHeight;
|
|
} else if (stretch.includes('minHeight') && targetHeight) {
|
|
miscStyle.minHeight = targetHeight;
|
|
}
|
|
if (stretch.includes('width') && targetWidth) {
|
|
miscStyle.width = targetWidth;
|
|
} else if (stretch.includes('minWidth') && targetWidth) {
|
|
miscStyle.minWidth = targetWidth;
|
|
}
|
|
}
|
|
if (!open) {
|
|
miscStyle.pointerEvents = 'none';
|
|
}
|
|
return /*#__PURE__*/react.createElement(Portal, {
|
|
open: forceRender || isNodeVisible,
|
|
getContainer: getPopupContainer && function () {
|
|
return getPopupContainer(target);
|
|
},
|
|
autoDestroy: autoDestroy
|
|
}, /*#__PURE__*/react.createElement(Mask, {
|
|
prefixCls: prefixCls,
|
|
open: open,
|
|
zIndex: zIndex,
|
|
mask: mask,
|
|
motion: maskMotion
|
|
}), /*#__PURE__*/react.createElement(rc_resize_observer_es/* default */.Z, {
|
|
onResize: onAlign,
|
|
disabled: !open
|
|
}, function (resizeObserverRef) {
|
|
return /*#__PURE__*/react.createElement(rc_motion_es, (0,esm_extends/* default */.Z)({
|
|
motionAppear: true,
|
|
motionEnter: true,
|
|
motionLeave: true,
|
|
removeOnLeave: false,
|
|
forceRender: forceRender,
|
|
leavedClassName: "".concat(prefixCls, "-hidden")
|
|
}, motion, {
|
|
onAppearPrepare: onPrepare,
|
|
onEnterPrepare: onPrepare,
|
|
visible: open,
|
|
onVisibleChanged: function onVisibleChanged(nextVisible) {
|
|
var _motion$onVisibleChan;
|
|
motion === null || motion === void 0 ? void 0 : (_motion$onVisibleChan = motion.onVisibleChanged) === null || _motion$onVisibleChan === void 0 ? void 0 : _motion$onVisibleChan.call(motion, nextVisible);
|
|
_onVisibleChanged(nextVisible);
|
|
}
|
|
}), function (_ref, motionRef) {
|
|
var motionClassName = _ref.className,
|
|
motionStyle = _ref.style;
|
|
var cls = classnames_default()(prefixCls, motionClassName, className);
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: es_ref_composeRef(resizeObserverRef, ref, motionRef),
|
|
className: cls,
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
'--arrow-x': "".concat(arrowPos.x || 0, "px"),
|
|
'--arrow-y': "".concat(arrowPos.y || 0, "px")
|
|
}, offsetStyle), miscStyle), motionStyle), {}, {
|
|
boxSizing: 'border-box',
|
|
zIndex: zIndex
|
|
}, style),
|
|
onMouseEnter: onMouseEnter,
|
|
onMouseLeave: onMouseLeave,
|
|
onClick: onClick
|
|
}, arrow && /*#__PURE__*/react.createElement(Arrow, {
|
|
prefixCls: prefixCls,
|
|
arrow: arrow,
|
|
arrowPos: arrowPos,
|
|
align: align
|
|
}), /*#__PURE__*/react.createElement(Popup_PopupContent, {
|
|
cache: !open
|
|
}, childNode));
|
|
});
|
|
}));
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var es_Popup = (Popup);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/TriggerWrapper.js
|
|
|
|
|
|
var TriggerWrapper = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var children = props.children,
|
|
getTriggerDOMNode = props.getTriggerDOMNode;
|
|
var canUseRef = es_ref_supportRef(children);
|
|
|
|
// When use `getTriggerDOMNode`, we should do additional work to get the real dom
|
|
var setRef = react.useCallback(function (node) {
|
|
es_ref_fillRef(ref, getTriggerDOMNode ? getTriggerDOMNode(node) : node);
|
|
}, [getTriggerDOMNode]);
|
|
var mergedRef = es_ref_useComposeRef(setRef, children.ref);
|
|
return canUseRef ? /*#__PURE__*/react.cloneElement(children, {
|
|
ref: mergedRef
|
|
}) : children;
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var es_TriggerWrapper = (TriggerWrapper);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/node_modules/@rc-component/trigger/es/index.js
|
|
|
|
|
|
|
|
var es_excluded = ["prefixCls", "children", "action", "showAction", "hideAction", "popupVisible", "defaultPopupVisible", "onPopupVisibleChange", "afterPopupVisibleChange", "mouseEnterDelay", "mouseLeaveDelay", "focusDelay", "blurDelay", "mask", "maskClosable", "getPopupContainer", "forceRender", "autoDestroy", "destroyPopupOnHide", "popup", "popupClassName", "popupStyle", "popupPlacement", "builtinPlacements", "popupAlign", "zIndex", "stretch", "getPopupClassNameFromAlign", "alignPoint", "onPopupClick", "onPopupAlign", "arrow", "popupMotion", "maskMotion", "popupTransitionName", "popupAnimation", "maskTransitionName", "maskAnimation", "className", "getTriggerDOMNode"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Removed Props List
|
|
// Seems this can be auto
|
|
// getDocument?: (element?: HTMLElement) => Document;
|
|
// New version will not wrap popup with `rc-trigger-popup-content` when multiple children
|
|
function generateTrigger() {
|
|
var PortalComponent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : es;
|
|
var Trigger = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-trigger-popup' : _props$prefixCls,
|
|
children = props.children,
|
|
_props$action = props.action,
|
|
action = _props$action === void 0 ? 'hover' : _props$action,
|
|
showAction = props.showAction,
|
|
hideAction = props.hideAction,
|
|
popupVisible = props.popupVisible,
|
|
defaultPopupVisible = props.defaultPopupVisible,
|
|
onPopupVisibleChange = props.onPopupVisibleChange,
|
|
afterPopupVisibleChange = props.afterPopupVisibleChange,
|
|
mouseEnterDelay = props.mouseEnterDelay,
|
|
_props$mouseLeaveDela = props.mouseLeaveDelay,
|
|
mouseLeaveDelay = _props$mouseLeaveDela === void 0 ? 0.1 : _props$mouseLeaveDela,
|
|
focusDelay = props.focusDelay,
|
|
blurDelay = props.blurDelay,
|
|
mask = props.mask,
|
|
_props$maskClosable = props.maskClosable,
|
|
maskClosable = _props$maskClosable === void 0 ? true : _props$maskClosable,
|
|
getPopupContainer = props.getPopupContainer,
|
|
forceRender = props.forceRender,
|
|
autoDestroy = props.autoDestroy,
|
|
destroyPopupOnHide = props.destroyPopupOnHide,
|
|
popup = props.popup,
|
|
popupClassName = props.popupClassName,
|
|
popupStyle = props.popupStyle,
|
|
popupPlacement = props.popupPlacement,
|
|
_props$builtinPlaceme = props.builtinPlacements,
|
|
builtinPlacements = _props$builtinPlaceme === void 0 ? {} : _props$builtinPlaceme,
|
|
popupAlign = props.popupAlign,
|
|
zIndex = props.zIndex,
|
|
stretch = props.stretch,
|
|
getPopupClassNameFromAlign = props.getPopupClassNameFromAlign,
|
|
alignPoint = props.alignPoint,
|
|
onPopupClick = props.onPopupClick,
|
|
onPopupAlign = props.onPopupAlign,
|
|
arrow = props.arrow,
|
|
popupMotion = props.popupMotion,
|
|
maskMotion = props.maskMotion,
|
|
popupTransitionName = props.popupTransitionName,
|
|
popupAnimation = props.popupAnimation,
|
|
maskTransitionName = props.maskTransitionName,
|
|
maskAnimation = props.maskAnimation,
|
|
className = props.className,
|
|
getTriggerDOMNode = props.getTriggerDOMNode,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, es_excluded);
|
|
var mergedAutoDestroy = autoDestroy || destroyPopupOnHide || false;
|
|
|
|
// =========================== Mobile ===========================
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
mobile = _React$useState2[0],
|
|
setMobile = _React$useState2[1];
|
|
hooks_useLayoutEffect(function () {
|
|
setMobile(isMobile());
|
|
}, []);
|
|
|
|
// ========================== Context ===========================
|
|
var subPopupElements = react.useRef({});
|
|
var parentContext = react.useContext(es_context);
|
|
var context = react.useMemo(function () {
|
|
return {
|
|
registerSubPopup: function registerSubPopup(id, subPopupEle) {
|
|
subPopupElements.current[id] = subPopupEle;
|
|
parentContext === null || parentContext === void 0 ? void 0 : parentContext.registerSubPopup(id, subPopupEle);
|
|
}
|
|
};
|
|
}, [parentContext]);
|
|
|
|
// =========================== Popup ============================
|
|
var id = useId();
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
popupEle = _React$useState4[0],
|
|
setPopupEle = _React$useState4[1];
|
|
var setPopupRef = useEvent(function (node) {
|
|
if (isDOM(node) && popupEle !== node) {
|
|
setPopupEle(node);
|
|
}
|
|
parentContext === null || parentContext === void 0 ? void 0 : parentContext.registerSubPopup(id, node);
|
|
});
|
|
|
|
// =========================== Target ===========================
|
|
// Use state to control here since `useRef` update not trigger render
|
|
var _React$useState5 = react.useState(null),
|
|
_React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2),
|
|
targetEle = _React$useState6[0],
|
|
setTargetEle = _React$useState6[1];
|
|
var setTargetRef = useEvent(function (node) {
|
|
if (isDOM(node) && targetEle !== node) {
|
|
setTargetEle(node);
|
|
}
|
|
});
|
|
|
|
// ========================== Children ==========================
|
|
var child = react.Children.only(children);
|
|
var originChildProps = (child === null || child === void 0 ? void 0 : child.props) || {};
|
|
var cloneProps = {};
|
|
var inPopupOrChild = useEvent(function (ele) {
|
|
var _getShadowRoot, _getShadowRoot2;
|
|
var childDOM = targetEle;
|
|
return (childDOM === null || childDOM === void 0 ? void 0 : childDOM.contains(ele)) || ((_getShadowRoot = getShadowRoot(childDOM)) === null || _getShadowRoot === void 0 ? void 0 : _getShadowRoot.host) === ele || ele === childDOM || (popupEle === null || popupEle === void 0 ? void 0 : popupEle.contains(ele)) || ((_getShadowRoot2 = getShadowRoot(popupEle)) === null || _getShadowRoot2 === void 0 ? void 0 : _getShadowRoot2.host) === ele || ele === popupEle || Object.values(subPopupElements.current).some(function (subPopupEle) {
|
|
return (subPopupEle === null || subPopupEle === void 0 ? void 0 : subPopupEle.contains(ele)) || ele === subPopupEle;
|
|
});
|
|
});
|
|
|
|
// =========================== Motion ===========================
|
|
var mergePopupMotion = getMotion(prefixCls, popupMotion, popupAnimation, popupTransitionName);
|
|
var mergeMaskMotion = getMotion(prefixCls, maskMotion, maskAnimation, maskTransitionName);
|
|
|
|
// ============================ Open ============================
|
|
var _React$useState7 = react.useState(defaultPopupVisible || false),
|
|
_React$useState8 = (0,slicedToArray/* default */.Z)(_React$useState7, 2),
|
|
internalOpen = _React$useState8[0],
|
|
setInternalOpen = _React$useState8[1];
|
|
|
|
// Render still use props as first priority
|
|
var mergedOpen = popupVisible !== null && popupVisible !== void 0 ? popupVisible : internalOpen;
|
|
|
|
// We use effect sync here in case `popupVisible` back to `undefined`
|
|
var setMergedOpen = useEvent(function (nextOpen) {
|
|
if (popupVisible === undefined) {
|
|
setInternalOpen(nextOpen);
|
|
}
|
|
});
|
|
hooks_useLayoutEffect(function () {
|
|
setInternalOpen(popupVisible || false);
|
|
}, [popupVisible]);
|
|
var openRef = react.useRef(mergedOpen);
|
|
openRef.current = mergedOpen;
|
|
var internalTriggerOpen = useEvent(function (nextOpen) {
|
|
if (mergedOpen !== nextOpen) {
|
|
setMergedOpen(nextOpen);
|
|
onPopupVisibleChange === null || onPopupVisibleChange === void 0 ? void 0 : onPopupVisibleChange(nextOpen);
|
|
}
|
|
});
|
|
|
|
// Trigger for delay
|
|
var delayRef = react.useRef();
|
|
var clearDelay = function clearDelay() {
|
|
clearTimeout(delayRef.current);
|
|
};
|
|
var triggerOpen = function triggerOpen(nextOpen) {
|
|
var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
clearDelay();
|
|
if (delay === 0) {
|
|
internalTriggerOpen(nextOpen);
|
|
} else {
|
|
delayRef.current = setTimeout(function () {
|
|
internalTriggerOpen(nextOpen);
|
|
}, delay * 1000);
|
|
}
|
|
};
|
|
react.useEffect(function () {
|
|
return clearDelay;
|
|
}, []);
|
|
|
|
// ========================== Motion ============================
|
|
var _React$useState9 = react.useState(false),
|
|
_React$useState10 = (0,slicedToArray/* default */.Z)(_React$useState9, 2),
|
|
inMotion = _React$useState10[0],
|
|
setInMotion = _React$useState10[1];
|
|
hooks_useLayoutEffect(function (firstMount) {
|
|
if (!firstMount || mergedOpen) {
|
|
setInMotion(true);
|
|
}
|
|
}, [mergedOpen]);
|
|
var _React$useState11 = react.useState(null),
|
|
_React$useState12 = (0,slicedToArray/* default */.Z)(_React$useState11, 2),
|
|
motionPrepareResolve = _React$useState12[0],
|
|
setMotionPrepareResolve = _React$useState12[1];
|
|
|
|
// =========================== Align ============================
|
|
var _React$useState13 = react.useState([0, 0]),
|
|
_React$useState14 = (0,slicedToArray/* default */.Z)(_React$useState13, 2),
|
|
mousePos = _React$useState14[0],
|
|
setMousePos = _React$useState14[1];
|
|
var setMousePosByEvent = function setMousePosByEvent(event) {
|
|
setMousePos([event.clientX, event.clientY]);
|
|
};
|
|
var _useAlign = useAlign(mergedOpen, popupEle, alignPoint ? mousePos : targetEle, popupPlacement, builtinPlacements, popupAlign, onPopupAlign),
|
|
_useAlign2 = (0,slicedToArray/* default */.Z)(_useAlign, 11),
|
|
ready = _useAlign2[0],
|
|
offsetX = _useAlign2[1],
|
|
offsetY = _useAlign2[2],
|
|
offsetR = _useAlign2[3],
|
|
offsetB = _useAlign2[4],
|
|
arrowX = _useAlign2[5],
|
|
arrowY = _useAlign2[6],
|
|
scaleX = _useAlign2[7],
|
|
scaleY = _useAlign2[8],
|
|
alignInfo = _useAlign2[9],
|
|
onAlign = _useAlign2[10];
|
|
var triggerAlign = useEvent(function () {
|
|
if (!inMotion) {
|
|
onAlign();
|
|
}
|
|
});
|
|
useWatch(mergedOpen, targetEle, popupEle, triggerAlign);
|
|
hooks_useLayoutEffect(function () {
|
|
triggerAlign();
|
|
}, [mousePos, popupPlacement]);
|
|
|
|
// When no builtinPlacements and popupAlign changed
|
|
hooks_useLayoutEffect(function () {
|
|
if (mergedOpen && !(builtinPlacements !== null && builtinPlacements !== void 0 && builtinPlacements[popupPlacement])) {
|
|
triggerAlign();
|
|
}
|
|
}, [JSON.stringify(popupAlign)]);
|
|
var alignedClassName = react.useMemo(function () {
|
|
var baseClassName = getAlignPopupClassName(builtinPlacements, prefixCls, alignInfo, alignPoint);
|
|
return classnames_default()(baseClassName, getPopupClassNameFromAlign === null || getPopupClassNameFromAlign === void 0 ? void 0 : getPopupClassNameFromAlign(alignInfo));
|
|
}, [alignInfo, getPopupClassNameFromAlign, builtinPlacements, prefixCls, alignPoint]);
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
forceAlign: triggerAlign
|
|
};
|
|
});
|
|
|
|
// ========================== Motion ============================
|
|
var onVisibleChanged = function onVisibleChanged(visible) {
|
|
setInMotion(false);
|
|
onAlign();
|
|
afterPopupVisibleChange === null || afterPopupVisibleChange === void 0 ? void 0 : afterPopupVisibleChange(visible);
|
|
};
|
|
|
|
// We will trigger align when motion is in prepare
|
|
var onPrepare = function onPrepare() {
|
|
return new Promise(function (resolve) {
|
|
setMotionPrepareResolve(function () {
|
|
return resolve;
|
|
});
|
|
});
|
|
};
|
|
hooks_useLayoutEffect(function () {
|
|
if (motionPrepareResolve) {
|
|
onAlign();
|
|
motionPrepareResolve();
|
|
setMotionPrepareResolve(null);
|
|
}
|
|
}, [motionPrepareResolve]);
|
|
|
|
// ========================== Stretch ===========================
|
|
var _React$useState15 = react.useState(0),
|
|
_React$useState16 = (0,slicedToArray/* default */.Z)(_React$useState15, 2),
|
|
targetWidth = _React$useState16[0],
|
|
setTargetWidth = _React$useState16[1];
|
|
var _React$useState17 = react.useState(0),
|
|
_React$useState18 = (0,slicedToArray/* default */.Z)(_React$useState17, 2),
|
|
targetHeight = _React$useState18[0],
|
|
setTargetHeight = _React$useState18[1];
|
|
var onTargetResize = function onTargetResize(_, ele) {
|
|
triggerAlign();
|
|
if (stretch) {
|
|
var rect = ele.getBoundingClientRect();
|
|
setTargetWidth(rect.width);
|
|
setTargetHeight(rect.height);
|
|
}
|
|
};
|
|
|
|
// =========================== Action ===========================
|
|
var _useAction = useAction(mobile, action, showAction, hideAction),
|
|
_useAction2 = (0,slicedToArray/* default */.Z)(_useAction, 2),
|
|
showActions = _useAction2[0],
|
|
hideActions = _useAction2[1];
|
|
|
|
// Util wrapper for trigger action
|
|
var wrapperAction = function wrapperAction(eventName, nextOpen, delay, preEvent) {
|
|
cloneProps[eventName] = function (event) {
|
|
var _originChildProps$eve;
|
|
preEvent === null || preEvent === void 0 ? void 0 : preEvent(event);
|
|
triggerOpen(nextOpen, delay);
|
|
|
|
// Pass to origin
|
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
(_originChildProps$eve = originChildProps[eventName]) === null || _originChildProps$eve === void 0 ? void 0 : _originChildProps$eve.call.apply(_originChildProps$eve, [originChildProps, event].concat(args));
|
|
};
|
|
};
|
|
|
|
// ======================= Action: Click ========================
|
|
var clickToShow = showActions.has('click');
|
|
var clickToHide = hideActions.has('click') || hideActions.has('contextMenu');
|
|
if (clickToShow || clickToHide) {
|
|
cloneProps.onClick = function (event) {
|
|
var _originChildProps$onC;
|
|
if (openRef.current && clickToHide) {
|
|
triggerOpen(false);
|
|
} else if (!openRef.current && clickToShow) {
|
|
setMousePosByEvent(event);
|
|
triggerOpen(true);
|
|
}
|
|
|
|
// Pass to origin
|
|
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
args[_key2 - 1] = arguments[_key2];
|
|
}
|
|
(_originChildProps$onC = originChildProps.onClick) === null || _originChildProps$onC === void 0 ? void 0 : _originChildProps$onC.call.apply(_originChildProps$onC, [originChildProps, event].concat(args));
|
|
};
|
|
}
|
|
|
|
// Click to hide is special action since click popup element should not hide
|
|
useWinClick(mergedOpen, clickToHide, targetEle, popupEle, mask, maskClosable, inPopupOrChild, triggerOpen);
|
|
|
|
// ======================= Action: Hover ========================
|
|
var hoverToShow = showActions.has('hover');
|
|
var hoverToHide = hideActions.has('hover');
|
|
var onPopupMouseEnter;
|
|
var onPopupMouseLeave;
|
|
if (hoverToShow) {
|
|
wrapperAction('onMouseEnter', true, mouseEnterDelay, function (event) {
|
|
setMousePosByEvent(event);
|
|
});
|
|
onPopupMouseEnter = function onPopupMouseEnter() {
|
|
// Only trigger re-open when popup is visible
|
|
if (mergedOpen || inMotion) {
|
|
triggerOpen(true, mouseEnterDelay);
|
|
}
|
|
};
|
|
|
|
// Align Point
|
|
if (alignPoint) {
|
|
cloneProps.onMouseMove = function (event) {
|
|
var _originChildProps$onM;
|
|
// setMousePosByEvent(event);
|
|
(_originChildProps$onM = originChildProps.onMouseMove) === null || _originChildProps$onM === void 0 ? void 0 : _originChildProps$onM.call(originChildProps, event);
|
|
};
|
|
}
|
|
}
|
|
if (hoverToHide) {
|
|
wrapperAction('onMouseLeave', false, mouseLeaveDelay);
|
|
onPopupMouseLeave = function onPopupMouseLeave() {
|
|
triggerOpen(false, mouseLeaveDelay);
|
|
};
|
|
}
|
|
|
|
// ======================= Action: Focus ========================
|
|
if (showActions.has('focus')) {
|
|
wrapperAction('onFocus', true, focusDelay);
|
|
}
|
|
if (hideActions.has('focus')) {
|
|
wrapperAction('onBlur', false, blurDelay);
|
|
}
|
|
|
|
// ==================== Action: ContextMenu =====================
|
|
if (showActions.has('contextMenu')) {
|
|
cloneProps.onContextMenu = function (event) {
|
|
var _originChildProps$onC2;
|
|
if (openRef.current && hideActions.has('contextMenu')) {
|
|
triggerOpen(false);
|
|
} else {
|
|
setMousePosByEvent(event);
|
|
triggerOpen(true);
|
|
}
|
|
event.preventDefault();
|
|
|
|
// Pass to origin
|
|
for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
|
args[_key3 - 1] = arguments[_key3];
|
|
}
|
|
(_originChildProps$onC2 = originChildProps.onContextMenu) === null || _originChildProps$onC2 === void 0 ? void 0 : _originChildProps$onC2.call.apply(_originChildProps$onC2, [originChildProps, event].concat(args));
|
|
};
|
|
}
|
|
|
|
// ========================= ClassName ==========================
|
|
if (className) {
|
|
cloneProps.className = classnames_default()(originChildProps.className, className);
|
|
}
|
|
|
|
// =========================== Render ===========================
|
|
var mergedChildrenProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, originChildProps), cloneProps);
|
|
|
|
// Pass props into cloneProps for nest usage
|
|
var passedProps = {};
|
|
var passedEventList = ['onContextMenu', 'onClick', 'onMouseDown', 'onTouchStart', 'onMouseEnter', 'onMouseLeave', 'onFocus', 'onBlur'];
|
|
passedEventList.forEach(function (eventName) {
|
|
if (restProps[eventName]) {
|
|
passedProps[eventName] = function () {
|
|
var _mergedChildrenProps$;
|
|
for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
|
|
args[_key4] = arguments[_key4];
|
|
}
|
|
(_mergedChildrenProps$ = mergedChildrenProps[eventName]) === null || _mergedChildrenProps$ === void 0 ? void 0 : _mergedChildrenProps$.call.apply(_mergedChildrenProps$, [mergedChildrenProps].concat(args));
|
|
restProps[eventName].apply(restProps, args);
|
|
};
|
|
}
|
|
});
|
|
|
|
// Child Node
|
|
var triggerNode = /*#__PURE__*/react.cloneElement(child, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedChildrenProps), passedProps));
|
|
var arrowPos = {
|
|
x: arrowX,
|
|
y: arrowY
|
|
};
|
|
var innerArrow = arrow ? (0,objectSpread2/* default */.Z)({}, arrow !== true ? arrow : {}) : null;
|
|
|
|
// Render
|
|
return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(rc_resize_observer_es/* default */.Z, {
|
|
disabled: !mergedOpen,
|
|
ref: setTargetRef,
|
|
onResize: onTargetResize
|
|
}, /*#__PURE__*/react.createElement(es_TriggerWrapper, {
|
|
getTriggerDOMNode: getTriggerDOMNode
|
|
}, triggerNode)), /*#__PURE__*/react.createElement(es_context.Provider, {
|
|
value: context
|
|
}, /*#__PURE__*/react.createElement(es_Popup, {
|
|
portal: PortalComponent,
|
|
ref: setPopupRef,
|
|
prefixCls: prefixCls,
|
|
popup: popup,
|
|
className: classnames_default()(popupClassName, alignedClassName),
|
|
style: popupStyle,
|
|
target: targetEle,
|
|
onMouseEnter: onPopupMouseEnter,
|
|
onMouseLeave: onPopupMouseLeave,
|
|
zIndex: zIndex
|
|
// Open
|
|
,
|
|
open: mergedOpen,
|
|
keepDom: inMotion
|
|
// Click
|
|
,
|
|
onClick: onPopupClick
|
|
// Mask
|
|
,
|
|
mask: mask
|
|
// Motion
|
|
,
|
|
motion: mergePopupMotion,
|
|
maskMotion: mergeMaskMotion,
|
|
onVisibleChanged: onVisibleChanged,
|
|
onPrepare: onPrepare
|
|
// Portal
|
|
,
|
|
forceRender: forceRender,
|
|
autoDestroy: mergedAutoDestroy,
|
|
getPopupContainer: getPopupContainer
|
|
// Arrow
|
|
,
|
|
align: alignInfo,
|
|
arrow: innerArrow,
|
|
arrowPos: arrowPos
|
|
// Align
|
|
,
|
|
ready: ready,
|
|
offsetX: offsetX,
|
|
offsetY: offsetY,
|
|
offsetR: offsetR,
|
|
offsetB: offsetB,
|
|
onAlign: triggerAlign
|
|
// Stretch
|
|
,
|
|
stretch: stretch,
|
|
targetWidth: targetWidth / scaleX,
|
|
targetHeight: targetHeight / scaleY
|
|
})));
|
|
});
|
|
if (false) {}
|
|
return Trigger;
|
|
}
|
|
/* harmony default export */ var trigger_es = (generateTrigger(es));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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(trigger_es, {
|
|
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/antd/node_modules/rc-picker/es/PresetPanel.js
|
|
|
|
|
|
function PresetPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
presets = props.presets,
|
|
_onClick = props.onClick,
|
|
onHover = props.onHover;
|
|
if (!presets.length) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-presets")
|
|
}, /*#__PURE__*/react.createElement("ul", null, presets.map(function (_ref, index) {
|
|
var label = _ref.label,
|
|
value = _ref.value;
|
|
return /*#__PURE__*/react.createElement("li", {
|
|
key: index,
|
|
onClick: function onClick() {
|
|
return _onClick === null || _onClick === void 0 ? void 0 : _onClick(executeValue(value));
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
return onHover === null || onHover === void 0 ? void 0 : onHover(executeValue(value));
|
|
},
|
|
onMouseLeave: function onMouseLeave() {
|
|
return onHover === null || onHover === void 0 ? void 0 : onHover(null);
|
|
}
|
|
}, label);
|
|
})));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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/antd/node_modules/rc-picker/es/utils/getClearIcon.js
|
|
|
|
|
|
function getClearIcon(prefixCls, allowClear, clearIcon) {
|
|
var mergedClearIcon = (0,esm_typeof/* default */.Z)(allowClear) === "object" ? allowClear.clearIcon : clearIcon;
|
|
return mergedClearIcon || /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-clear-btn")
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// TMP type to fit for ts 3.9.2
|
|
|
|
function InnerPicker(props) {
|
|
var _classNames2;
|
|
var _ref = props,
|
|
_ref$prefixCls = _ref.prefixCls,
|
|
prefixCls = _ref$prefixCls === void 0 ? 'rc-picker' : _ref$prefixCls,
|
|
id = _ref.id,
|
|
name = _ref.name,
|
|
tabIndex = _ref.tabIndex,
|
|
style = _ref.style,
|
|
className = _ref.className,
|
|
dropdownClassName = _ref.dropdownClassName,
|
|
dropdownAlign = _ref.dropdownAlign,
|
|
popupStyle = _ref.popupStyle,
|
|
transitionName = _ref.transitionName,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale,
|
|
inputReadOnly = _ref.inputReadOnly,
|
|
allowClear = _ref.allowClear,
|
|
autoFocus = _ref.autoFocus,
|
|
showTime = _ref.showTime,
|
|
_ref$picker = _ref.picker,
|
|
picker = _ref$picker === void 0 ? 'date' : _ref$picker,
|
|
format = _ref.format,
|
|
use12Hours = _ref.use12Hours,
|
|
value = _ref.value,
|
|
defaultValue = _ref.defaultValue,
|
|
presets = _ref.presets,
|
|
open = _ref.open,
|
|
defaultOpen = _ref.defaultOpen,
|
|
defaultOpenValue = _ref.defaultOpenValue,
|
|
suffixIcon = _ref.suffixIcon,
|
|
clearIcon = _ref.clearIcon,
|
|
disabled = _ref.disabled,
|
|
disabledDate = _ref.disabledDate,
|
|
placeholder = _ref.placeholder,
|
|
getPopupContainer = _ref.getPopupContainer,
|
|
pickerRef = _ref.pickerRef,
|
|
panelRender = _ref.panelRender,
|
|
onChange = _ref.onChange,
|
|
onOpenChange = _ref.onOpenChange,
|
|
onFocus = _ref.onFocus,
|
|
onBlur = _ref.onBlur,
|
|
onMouseDown = _ref.onMouseDown,
|
|
onMouseUp = _ref.onMouseUp,
|
|
onMouseEnter = _ref.onMouseEnter,
|
|
onMouseLeave = _ref.onMouseLeave,
|
|
onContextMenu = _ref.onContextMenu,
|
|
onClick = _ref.onClick,
|
|
_onKeyDown = _ref.onKeyDown,
|
|
_onSelect = _ref.onSelect,
|
|
direction = _ref.direction,
|
|
_ref$autoComplete = _ref.autoComplete,
|
|
autoComplete = _ref$autoComplete === void 0 ? 'off' : _ref$autoComplete,
|
|
inputRender = _ref.inputRender,
|
|
changeOnBlur = _ref.changeOnBlur;
|
|
var inputRef = react.useRef(null);
|
|
var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
|
|
var presetList = usePresets(presets);
|
|
|
|
// ============================ 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 = useMergedState(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 = useMergedState(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 && !dateUtil_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 */
|
|
{
|
|
es_warning(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 onInternalBlur = function onInternalBlur(e) {
|
|
if (changeOnBlur) {
|
|
triggerChange(selectedValue);
|
|
}
|
|
onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
|
|
};
|
|
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: onInternalBlur,
|
|
changeOnBlur: changeOnBlur
|
|
}),
|
|
_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() {
|
|
var _inputRef$current;
|
|
(_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus();
|
|
},
|
|
blur: function blur() {
|
|
var _inputRef$current2;
|
|
(_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 ? void 0 : _inputRef$current2.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("div", {
|
|
className: "".concat(prefixCls, "-panel-layout")
|
|
}, /*#__PURE__*/react.createElement(PresetPanel, {
|
|
prefixCls: prefixCls,
|
|
presets: presetList,
|
|
onClick: function onClick(nextValue) {
|
|
triggerChange(nextValue);
|
|
triggerOpen(false);
|
|
}
|
|
}), /*#__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"),
|
|
ref: panelDivRef,
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
}
|
|
}, panelNode);
|
|
var suffixNode;
|
|
if (suffixIcon) {
|
|
suffixNode = /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-suffix"),
|
|
onMouseDown: function onMouseDown(e) {
|
|
// Not lost focus
|
|
e.preventDefault();
|
|
}
|
|
}, suffixIcon);
|
|
}
|
|
|
|
// ============================ Clear ============================
|
|
if (false) {}
|
|
var mergedClearIcon = getClearIcon(prefixCls, allowClear, clearIcon);
|
|
var 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"
|
|
}, mergedClearIcon);
|
|
var mergedAllowClear = !!allowClear && mergedValue && !disabled;
|
|
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),
|
|
name: name
|
|
}, pickAttrs(props, {
|
|
aria: true,
|
|
data: true
|
|
})), {}, {
|
|
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',
|
|
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, mergedAllowClear && 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));
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "pickerRef", /*#__PURE__*/react.createRef());
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "focus", function () {
|
|
if (_this.pickerRef.current) {
|
|
_this.pickerRef.current.focus();
|
|
}
|
|
});
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_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/antd/node_modules/rc-picker/es/hooks/useRangeDisabled.js
|
|
|
|
|
|
|
|
function useRangeDisabled(_ref, firstTimeOpen) {
|
|
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 (disabled[0] || disabledDate && disabledDate(date)) {
|
|
return true;
|
|
}
|
|
|
|
// Disabled range
|
|
if (disabled[1] && endDate) {
|
|
return !isSameDate(generateConfig, date, endDate) && generateConfig.isAfter(date, endDate);
|
|
}
|
|
|
|
// Disabled part
|
|
if (!firstTimeOpen && 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, firstTimeOpen]);
|
|
var disabledEndDate = react.useCallback(function (date) {
|
|
if (disabled[1] || disabledDate && disabledDate(date)) {
|
|
return true;
|
|
}
|
|
|
|
// Disabled range
|
|
if (disabled[0] && startDate) {
|
|
return !isSameDate(generateConfig, date, endDate) && generateConfig.isAfter(startDate, date);
|
|
}
|
|
|
|
// Disabled part
|
|
if (!firstTimeOpen && 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, firstTimeOpen]);
|
|
return [disabledStartDate, disabledEndDate];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/node_modules/rc-picker/es/hooks/useRangeOpen.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* 1. Click input to show picker
|
|
* 2. Calculate next open index
|
|
*
|
|
* If click `confirm`:
|
|
* 3. Hide current picker
|
|
* 4. Open next index picker if exist
|
|
*
|
|
* If not `changeOnBlur` and click outside:
|
|
* 3. Hide picker
|
|
*
|
|
* If `changeOnBlur` and click outside:
|
|
* 3. Hide current picker
|
|
* 4. Open next index picker if exist
|
|
*/
|
|
|
|
/**
|
|
* Auto control of open state
|
|
*/
|
|
function useRangeOpen(defaultOpen, open, activePickerIndex, changeOnBlur, startInputRef, endInputRef, startSelectedValue, endSelectedValue, disabled, onOpenChange) {
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
firstTimeOpen = _React$useState2[0],
|
|
setFirstTimeOpen = _React$useState2[1];
|
|
var _useMergedState = useMergedState(defaultOpen || false, {
|
|
value: open
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
afferentOpen = _useMergedState2[0],
|
|
setAfferentOpen = _useMergedState2[1];
|
|
var _useMergedState3 = useMergedState(defaultOpen || false, {
|
|
value: open,
|
|
onChange: function onChange(nextOpen) {
|
|
onOpenChange === null || onOpenChange === void 0 ? void 0 : onOpenChange(nextOpen);
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
mergedOpen = _useMergedState4[0],
|
|
setMergedOpen = _useMergedState4[1];
|
|
var _useMergedState5 = useMergedState(0, {
|
|
value: activePickerIndex
|
|
}),
|
|
_useMergedState6 = (0,slicedToArray/* default */.Z)(_useMergedState5, 2),
|
|
mergedActivePickerIndex = _useMergedState6[0],
|
|
setMergedActivePickerIndex = _useMergedState6[1];
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
nextActiveIndex = _React$useState4[0],
|
|
setNextActiveIndex = _React$useState4[1];
|
|
react.useEffect(function () {
|
|
if (mergedOpen) {
|
|
setFirstTimeOpen(true);
|
|
}
|
|
}, [mergedOpen]);
|
|
var queryNextIndex = function queryNextIndex(index) {
|
|
return index === 0 ? 1 : 0;
|
|
};
|
|
var triggerOpen = useEvent(function (nextOpen, index, source) {
|
|
if (index === false) {
|
|
// Only when `nextOpen` is false and no need open to next index
|
|
setMergedOpen(nextOpen);
|
|
} else if (nextOpen) {
|
|
setMergedActivePickerIndex(index);
|
|
setMergedOpen(nextOpen);
|
|
var nextIndex = queryNextIndex(index);
|
|
|
|
// Record next open index
|
|
if (!mergedOpen ||
|
|
// Also set next index if next is empty
|
|
![startSelectedValue, endSelectedValue][nextIndex]) {
|
|
setNextActiveIndex(nextIndex);
|
|
} else {
|
|
setFirstTimeOpen(false);
|
|
if (nextActiveIndex !== null) {
|
|
setNextActiveIndex(null);
|
|
}
|
|
}
|
|
} else if (source === 'confirm' || source === 'blur' && changeOnBlur) {
|
|
var customNextActiveIndex = afferentOpen ? queryNextIndex(index) : nextActiveIndex;
|
|
if (customNextActiveIndex !== null) {
|
|
setFirstTimeOpen(false);
|
|
setMergedActivePickerIndex(customNextActiveIndex);
|
|
}
|
|
setNextActiveIndex(null);
|
|
|
|
// Focus back
|
|
if (customNextActiveIndex !== null && !disabled[customNextActiveIndex]) {
|
|
es_raf(function () {
|
|
var _ref$current;
|
|
var ref = [startInputRef, endInputRef][customNextActiveIndex];
|
|
(_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
|
|
});
|
|
} else {
|
|
setMergedOpen(false);
|
|
}
|
|
} else {
|
|
setMergedOpen(false);
|
|
setAfferentOpen(false);
|
|
}
|
|
});
|
|
return [mergedOpen, mergedActivePickerIndex, firstTimeOpen, triggerOpen];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/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/antd/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;
|
|
}
|
|
|
|
// TMP type to fit for ts 3.9.2
|
|
|
|
function InnerRangePicker(props) {
|
|
var _classNames2, _classNames3, _classNames4;
|
|
var _ref = props,
|
|
_ref$prefixCls = _ref.prefixCls,
|
|
prefixCls = _ref$prefixCls === void 0 ? 'rc-picker' : _ref$prefixCls,
|
|
id = _ref.id,
|
|
style = _ref.style,
|
|
className = _ref.className,
|
|
popupStyle = _ref.popupStyle,
|
|
dropdownClassName = _ref.dropdownClassName,
|
|
transitionName = _ref.transitionName,
|
|
dropdownAlign = _ref.dropdownAlign,
|
|
getPopupContainer = _ref.getPopupContainer,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale,
|
|
placeholder = _ref.placeholder,
|
|
autoFocus = _ref.autoFocus,
|
|
disabled = _ref.disabled,
|
|
format = _ref.format,
|
|
_ref$picker = _ref.picker,
|
|
picker = _ref$picker === void 0 ? 'date' : _ref$picker,
|
|
showTime = _ref.showTime,
|
|
use12Hours = _ref.use12Hours,
|
|
_ref$separator = _ref.separator,
|
|
separator = _ref$separator === void 0 ? '~' : _ref$separator,
|
|
value = _ref.value,
|
|
defaultValue = _ref.defaultValue,
|
|
defaultPickerValue = _ref.defaultPickerValue,
|
|
open = _ref.open,
|
|
defaultOpen = _ref.defaultOpen,
|
|
disabledDate = _ref.disabledDate,
|
|
_disabledTime = _ref.disabledTime,
|
|
dateRender = _ref.dateRender,
|
|
monthCellRender = _ref.monthCellRender,
|
|
cellRender = _ref.cellRender,
|
|
panelRender = _ref.panelRender,
|
|
presets = _ref.presets,
|
|
ranges = _ref.ranges,
|
|
allowEmpty = _ref.allowEmpty,
|
|
allowClear = _ref.allowClear,
|
|
suffixIcon = _ref.suffixIcon,
|
|
clearIcon = _ref.clearIcon,
|
|
pickerRef = _ref.pickerRef,
|
|
inputReadOnly = _ref.inputReadOnly,
|
|
mode = _ref.mode,
|
|
renderExtraFooter = _ref.renderExtraFooter,
|
|
onChange = _ref.onChange,
|
|
onOpenChange = _ref.onOpenChange,
|
|
onPanelChange = _ref.onPanelChange,
|
|
onCalendarChange = _ref.onCalendarChange,
|
|
_onFocus = _ref.onFocus,
|
|
onBlur = _ref.onBlur,
|
|
onMouseDown = _ref.onMouseDown,
|
|
onMouseUp = _ref.onMouseUp,
|
|
onMouseEnter = _ref.onMouseEnter,
|
|
onMouseLeave = _ref.onMouseLeave,
|
|
onClick = _ref.onClick,
|
|
_onOk = _ref.onOk,
|
|
_onKeyDown = _ref.onKeyDown,
|
|
components = _ref.components,
|
|
order = _ref.order,
|
|
direction = _ref.direction,
|
|
activePickerIndex = _ref.activePickerIndex,
|
|
_ref$autoComplete = _ref.autoComplete,
|
|
autoComplete = _ref$autoComplete === void 0 ? 'off' : _ref$autoComplete,
|
|
changeOnBlur = _ref.changeOnBlur;
|
|
var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
|
|
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));
|
|
|
|
// 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 _useMergedState = useMergedState(null, {
|
|
value: value,
|
|
defaultValue: defaultValue,
|
|
postState: function postState(values) {
|
|
return picker === 'time' && !order ? values : reorderValues(values, generateConfig);
|
|
}
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
mergedValue = _useMergedState2[0],
|
|
setInnerValue = _useMergedState2[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 _useMergedState3 = useMergedState(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] && !postValues && !getValue(postValues, i) && !getValue(allowEmpty, i)) {
|
|
postValues = updateValues(postValues, generateConfig.getNow(), i);
|
|
}
|
|
}
|
|
return postValues;
|
|
}
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
selectedValue = _useMergedState4[0],
|
|
setSelectedValue = _useMergedState4[1];
|
|
|
|
// ============================= Modes =============================
|
|
var _useMergedState5 = useMergedState([picker, picker], {
|
|
value: mode
|
|
}),
|
|
_useMergedState6 = (0,slicedToArray/* default */.Z)(_useMergedState5, 2),
|
|
mergedModes = _useMergedState6[0],
|
|
setInnerModes = _useMergedState6[1];
|
|
(0,react.useEffect)(function () {
|
|
setInnerModes([picker, picker]);
|
|
}, [picker]);
|
|
var triggerModesChange = function triggerModesChange(modes, values) {
|
|
setInnerModes(modes);
|
|
if (onPanelChange) {
|
|
onPanelChange(values, modes);
|
|
}
|
|
};
|
|
|
|
// ============================= Open ==============================
|
|
var _useRangeOpen = useRangeOpen(defaultOpen, open, activePickerIndex, changeOnBlur, startInputRef, endInputRef, getValue(selectedValue, 0), getValue(selectedValue, 1), mergedDisabled, onOpenChange),
|
|
_useRangeOpen2 = (0,slicedToArray/* default */.Z)(_useRangeOpen, 4),
|
|
mergedOpen = _useRangeOpen2[0],
|
|
mergedActivePickerIndex = _useRangeOpen2[1],
|
|
firstTimeOpen = _useRangeOpen2[2],
|
|
_triggerOpen = _useRangeOpen2[3];
|
|
var startOpen = mergedOpen && mergedActivePickerIndex === 0;
|
|
var endOpen = mergedOpen && mergedActivePickerIndex === 1;
|
|
|
|
// ========================= Disable Date ==========================
|
|
var _useRangeDisabled = useRangeDisabled({
|
|
picker: picker,
|
|
selectedValue: selectedValue,
|
|
locale: locale,
|
|
disabled: mergedDisabled,
|
|
disabledDate: disabledDate,
|
|
generateConfig: generateConfig
|
|
}, !mergedOpen || firstTimeOpen),
|
|
_useRangeDisabled2 = (0,slicedToArray/* default */.Z)(_useRangeDisabled, 2),
|
|
disabledStartDate = _useRangeDisabled2[0],
|
|
disabledEndDate = _useRangeDisabled2[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 ============================
|
|
function triggerOpenAndFocus(index) {
|
|
_triggerOpen(true, index, 'open');
|
|
// Use setTimeout to make sure panel DOM exists
|
|
es_raf(function () {
|
|
var _inputRef$current;
|
|
var inputRef = [startInputRef, endInputRef][index];
|
|
(_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _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];
|
|
}
|
|
} 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 && (!dateUtil_isEqual(generateConfig, getValue(mergedValue, 0), startValue) || !dateUtil_isEqual(generateConfig, getValue(mergedValue, 1), endValue))) {
|
|
onChange(values, [startStr, endStr]);
|
|
}
|
|
}
|
|
}
|
|
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 */
|
|
{
|
|
es_warning(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 =============================
|
|
// We call effect to update `delayOpen` here since
|
|
// when popup closed and input focused, should not trigger change when click another input
|
|
var _React$useState = react.useState(mergedOpen),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
delayOpen = _React$useState2[0],
|
|
setDelayOpen = _React$useState2[1];
|
|
react.useEffect(function () {
|
|
setDelayOpen(mergedOpen);
|
|
}, [mergedOpen]);
|
|
var onInternalBlur = function onInternalBlur(e) {
|
|
if (changeOnBlur && delayOpen) {
|
|
var selectedIndexValue = getValue(selectedValue, mergedActivePickerIndex);
|
|
if (selectedIndexValue) {
|
|
triggerChange(selectedValue, mergedActivePickerIndex);
|
|
}
|
|
}
|
|
return onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
|
|
};
|
|
var getSharedInputHookProps = function getSharedInputHookProps(index, resetText) {
|
|
return {
|
|
blurToCancel: !changeOnBlur && needConfirmButton,
|
|
forwardKeyDown: forwardKeyDown,
|
|
onBlur: onInternalBlur,
|
|
isClickOutside: function isClickOutside(target) {
|
|
return !elementsContains([panelDivRef.current, startInputDivRef.current, endInputDivRef.current, containerRef.current], target);
|
|
},
|
|
onFocus: function onFocus(e) {
|
|
if (_onFocus) {
|
|
_onFocus(e);
|
|
}
|
|
},
|
|
triggerOpen: function triggerOpen(newOpen) {
|
|
if (newOpen) {
|
|
_triggerOpen(newOpen, index, 'open');
|
|
} else {
|
|
_triggerOpen(newOpen,
|
|
// Close directly if no selected value provided
|
|
getValue(selectedValue, index) ? index : false, 'blur');
|
|
}
|
|
},
|
|
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();
|
|
|
|
// Switch
|
|
_triggerOpen(false, mergedActivePickerIndex, 'confirm');
|
|
},
|
|
onCancel: function onCancel() {
|
|
_triggerOpen(false, index, 'cancel');
|
|
setSelectedValue(mergedValue);
|
|
resetText();
|
|
}
|
|
};
|
|
};
|
|
var sharedPickerInput = {
|
|
onKeyDown: function onKeyDown(e, preventDefault) {
|
|
_onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(e, preventDefault);
|
|
},
|
|
changeOnBlur: changeOnBlur
|
|
};
|
|
var _usePickerInput = usePickerInput((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, getSharedInputHookProps(0, resetStartText)), {}, {
|
|
open: startOpen,
|
|
value: startText
|
|
}, sharedPickerInput)),
|
|
_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
|
|
}, sharedPickerInput)),
|
|
_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]);
|
|
var mergedCellRender = useCellRender({
|
|
cellRender: cellRender,
|
|
monthCellRender: monthCellRender,
|
|
dateRender: dateRender
|
|
});
|
|
var panelDateRender = react.useMemo(function () {
|
|
if (!mergedCellRender) return undefined;
|
|
return function (date, info) {
|
|
return mergedCellRender(date, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, info), {}, {
|
|
range: mergedActivePickerIndex ? 'end' : 'start'
|
|
}));
|
|
};
|
|
}, [mergedActivePickerIndex, mergedCellRender]);
|
|
|
|
// ============================ 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 presetList = usePresets(presets, ranges);
|
|
|
|
// ============================= 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
|
|
});
|
|
}
|
|
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, {
|
|
cellRender: 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)
|
|
// defaultPickerValue={undefined}
|
|
})));
|
|
}
|
|
|
|
var arrowLeft = 0;
|
|
var panelLeft = 0;
|
|
if (mergedActivePickerIndex && startInputDivRef.current && separatorRef.current && panelDivRef.current && arrowRef.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;
|
|
var panelWidth = panelDivRef.current.offsetWidth;
|
|
var arrowWidth = arrowRef.current.offsetWidth;
|
|
if (panelWidth && arrowWidth && arrowLeft > panelWidth - arrowWidth - (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,
|
|
onOk: function onOk() {
|
|
var selectedIndexValue = getValue(selectedValue, mergedActivePickerIndex);
|
|
if (selectedIndexValue) {
|
|
triggerChange(selectedValue, mergedActivePickerIndex);
|
|
_onOk === null || _onOk === void 0 ? void 0 : _onOk(selectedValue);
|
|
|
|
// Switch
|
|
_triggerOpen(false, mergedActivePickerIndex, 'confirm');
|
|
}
|
|
}
|
|
});
|
|
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("div", {
|
|
className: "".concat(prefixCls, "-panel-layout")
|
|
}, /*#__PURE__*/react.createElement(PresetPanel, {
|
|
prefixCls: prefixCls,
|
|
presets: presetList,
|
|
onClick: function onClick(nextValue) {
|
|
triggerChange(nextValue, null);
|
|
_triggerOpen(false, mergedActivePickerIndex, 'preset');
|
|
},
|
|
onHover: function onHover(hoverValue) {
|
|
setRangeHoverValue(hoverValue);
|
|
}
|
|
}), /*#__PURE__*/react.createElement("div", 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"),
|
|
onMouseDown: function onMouseDown(e) {
|
|
// Not lost focus
|
|
e.preventDefault();
|
|
}
|
|
}, suffixIcon);
|
|
}
|
|
var mergedClearIcon = getClearIcon(prefixCls, allowClear, clearIcon);
|
|
var 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, 'clear');
|
|
},
|
|
className: "".concat(prefixCls, "-clear"),
|
|
role: "button"
|
|
}, mergedClearIcon);
|
|
var mergedAllowClear = allowClear && (getValue(mergedValue, 0) && !mergedDisabled[0] || getValue(mergedValue, 1) && !mergedDisabled[1]);
|
|
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();
|
|
}
|
|
|
|
// Switch
|
|
var nextActivePickerIndex = mergedActivePickerIndex === 0 ? 1 : 0;
|
|
if (mergedDisabled[nextActivePickerIndex]) {
|
|
_triggerOpen(false, false, 'confirm');
|
|
} else {
|
|
_triggerOpen(false, mergedActivePickerIndex, 'confirm');
|
|
}
|
|
} 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
|
|
}, pickAttrs(props, {
|
|
aria: true,
|
|
data: true
|
|
})), /*#__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, mergedAllowClear && 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));
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "pickerRef", /*#__PURE__*/react.createRef());
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "focus", function () {
|
|
if (_this.pickerRef.current) {
|
|
_this.pickerRef.current.focus();
|
|
}
|
|
});
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_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/antd/node_modules/rc-picker/es/index.js
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var rc_picker_es = (es_Picker);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/_util/statusUtils.js
|
|
var statusUtils = __webpack_require__(9708);
|
|
// 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/hooks/useSize.js
|
|
var useSize = __webpack_require__(98675);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/form/context.js
|
|
var form_context = __webpack_require__(65223);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/locale/useLocale.js
|
|
var useLocale = __webpack_require__(10110);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/space/Compact.js
|
|
var Compact = __webpack_require__(4173);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/date-picker/locale/en_US.js + 1 modules
|
|
var en_US = __webpack_require__(16516);
|
|
// EXTERNAL MODULE: ./node_modules/@ctrl/tinycolor/dist/module/index.js
|
|
var dist_module = __webpack_require__(10274);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/input/style/index.js
|
|
var input_style = __webpack_require__(47673);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/index.js
|
|
var es_style = __webpack_require__(14747);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/roundedArrow.js
|
|
var roundedArrow = __webpack_require__(79511);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/compact-item.js
|
|
var compact_item = __webpack_require__(80110);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/motion/slide.js
|
|
var slide = __webpack_require__(67771);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/style/motion/move.js
|
|
var move = __webpack_require__(33297);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/theme/util/statistic.js
|
|
var statistic = __webpack_require__(45503);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/theme/util/genComponentStyleHook.js
|
|
var genComponentStyleHook = __webpack_require__(67968);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/style/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const genPikerPadding = (token, inputHeight, fontSize, paddingHorizontal) => {
|
|
const {
|
|
lineHeight
|
|
} = token;
|
|
const fontHeight = Math.floor(fontSize * lineHeight) + 2;
|
|
const paddingTop = Math.max((inputHeight - fontHeight) / 2, 0);
|
|
const paddingBottom = Math.max(inputHeight - fontHeight - paddingTop, 0);
|
|
return {
|
|
padding: `${paddingTop}px ${paddingHorizontal}px ${paddingBottom}px`
|
|
};
|
|
};
|
|
const genPickerCellInnerStyle = token => {
|
|
const {
|
|
componentCls,
|
|
pickerCellCls,
|
|
pickerCellInnerCls,
|
|
cellHeight,
|
|
motionDurationSlow,
|
|
borderRadiusSM,
|
|
motionDurationMid,
|
|
cellHoverBg,
|
|
lineWidth,
|
|
lineType,
|
|
colorPrimary,
|
|
cellActiveWithRangeBg,
|
|
colorTextLightSolid,
|
|
controlHeightSM,
|
|
cellRangeBorderColor,
|
|
pickerCellBorderGap,
|
|
cellHoverWithRangeBg,
|
|
cellWidth,
|
|
colorTextDisabled,
|
|
cellBgDisabled
|
|
} = token;
|
|
return {
|
|
'&::before': {
|
|
position: 'absolute',
|
|
top: '50%',
|
|
insetInlineStart: 0,
|
|
insetInlineEnd: 0,
|
|
zIndex: 1,
|
|
height: cellHeight,
|
|
transform: 'translateY(-50%)',
|
|
transition: `all ${motionDurationSlow}`,
|
|
content: '""'
|
|
},
|
|
// >>> Default
|
|
[pickerCellInnerCls]: {
|
|
position: 'relative',
|
|
zIndex: 2,
|
|
display: 'inline-block',
|
|
minWidth: cellHeight,
|
|
height: cellHeight,
|
|
lineHeight: `${cellHeight}px`,
|
|
borderRadius: borderRadiusSM,
|
|
transition: `background ${motionDurationMid}, border ${motionDurationMid}`
|
|
},
|
|
[`&-range-hover-start, &-range-hover-end`]: {
|
|
[pickerCellInnerCls]: {
|
|
borderStartEndRadius: 0,
|
|
borderEndEndRadius: 0
|
|
}
|
|
},
|
|
// >>> Hover
|
|
[`&:hover:not(${pickerCellCls}-in-view),
|
|
&:hover:not(${pickerCellCls}-selected):not(${pickerCellCls}-range-start):not(${pickerCellCls}-range-end):not(${pickerCellCls}-range-hover-start):not(${pickerCellCls}-range-hover-end)`]: {
|
|
[pickerCellInnerCls]: {
|
|
background: cellHoverBg
|
|
}
|
|
},
|
|
// >>> Today
|
|
[`&-in-view${pickerCellCls}-today ${pickerCellInnerCls}`]: {
|
|
'&::before': {
|
|
position: 'absolute',
|
|
top: 0,
|
|
insetInlineEnd: 0,
|
|
bottom: 0,
|
|
insetInlineStart: 0,
|
|
zIndex: 1,
|
|
border: `${lineWidth}px ${lineType} ${colorPrimary}`,
|
|
borderRadius: borderRadiusSM,
|
|
content: '""'
|
|
}
|
|
},
|
|
// >>> In Range
|
|
[`&-in-view${pickerCellCls}-in-range`]: {
|
|
position: 'relative',
|
|
'&::before': {
|
|
background: cellActiveWithRangeBg
|
|
}
|
|
},
|
|
// >>> Selected
|
|
[`&-in-view${pickerCellCls}-selected ${pickerCellInnerCls},
|
|
&-in-view${pickerCellCls}-range-start ${pickerCellInnerCls},
|
|
&-in-view${pickerCellCls}-range-end ${pickerCellInnerCls}`]: {
|
|
color: colorTextLightSolid,
|
|
background: colorPrimary
|
|
},
|
|
[`&-in-view${pickerCellCls}-range-start:not(${pickerCellCls}-range-start-single),
|
|
&-in-view${pickerCellCls}-range-end:not(${pickerCellCls}-range-end-single)`]: {
|
|
'&::before': {
|
|
background: cellActiveWithRangeBg
|
|
}
|
|
},
|
|
[`&-in-view${pickerCellCls}-range-start::before`]: {
|
|
insetInlineStart: '50%'
|
|
},
|
|
[`&-in-view${pickerCellCls}-range-end::before`]: {
|
|
insetInlineEnd: '50%'
|
|
},
|
|
// >>> Range Hover
|
|
[`&-in-view${pickerCellCls}-range-hover-start:not(${pickerCellCls}-in-range):not(${pickerCellCls}-range-start):not(${pickerCellCls}-range-end),
|
|
&-in-view${pickerCellCls}-range-hover-end:not(${pickerCellCls}-in-range):not(${pickerCellCls}-range-start):not(${pickerCellCls}-range-end),
|
|
&-in-view${pickerCellCls}-range-hover-start${pickerCellCls}-range-start-single,
|
|
&-in-view${pickerCellCls}-range-hover-start${pickerCellCls}-range-start${pickerCellCls}-range-end${pickerCellCls}-range-end-near-hover,
|
|
&-in-view${pickerCellCls}-range-hover-end${pickerCellCls}-range-start${pickerCellCls}-range-end${pickerCellCls}-range-start-near-hover,
|
|
&-in-view${pickerCellCls}-range-hover-end${pickerCellCls}-range-end-single,
|
|
&-in-view${pickerCellCls}-range-hover:not(${pickerCellCls}-in-range)`]: {
|
|
'&::after': {
|
|
position: 'absolute',
|
|
top: '50%',
|
|
zIndex: 0,
|
|
height: controlHeightSM,
|
|
borderTop: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
borderBottom: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
transform: 'translateY(-50%)',
|
|
transition: `all ${motionDurationSlow}`,
|
|
content: '""'
|
|
}
|
|
},
|
|
// Add space for stash
|
|
[`&-range-hover-start::after,
|
|
&-range-hover-end::after,
|
|
&-range-hover::after`]: {
|
|
insetInlineEnd: 0,
|
|
insetInlineStart: pickerCellBorderGap
|
|
},
|
|
// Hover with in range
|
|
[`&-in-view${pickerCellCls}-in-range${pickerCellCls}-range-hover::before,
|
|
&-in-view${pickerCellCls}-in-range${pickerCellCls}-range-hover-start::before,
|
|
&-in-view${pickerCellCls}-in-range${pickerCellCls}-range-hover-end::before,
|
|
&-in-view${pickerCellCls}-range-start${pickerCellCls}-range-hover::before,
|
|
&-in-view${pickerCellCls}-range-end${pickerCellCls}-range-hover::before,
|
|
&-in-view${pickerCellCls}-range-start:not(${pickerCellCls}-range-start-single)${pickerCellCls}-range-hover-start::before,
|
|
&-in-view${pickerCellCls}-range-end:not(${pickerCellCls}-range-end-single)${pickerCellCls}-range-hover-end::before,
|
|
${componentCls}-panel
|
|
> :not(${componentCls}-date-panel)
|
|
&-in-view${pickerCellCls}-in-range${pickerCellCls}-range-hover-start::before,
|
|
${componentCls}-panel
|
|
> :not(${componentCls}-date-panel)
|
|
&-in-view${pickerCellCls}-in-range${pickerCellCls}-range-hover-end::before`]: {
|
|
background: cellHoverWithRangeBg
|
|
},
|
|
// range start border-radius
|
|
[`&-in-view${pickerCellCls}-range-start:not(${pickerCellCls}-range-start-single):not(${pickerCellCls}-range-end) ${pickerCellInnerCls}`]: {
|
|
borderStartStartRadius: borderRadiusSM,
|
|
borderEndStartRadius: borderRadiusSM,
|
|
borderStartEndRadius: 0,
|
|
borderEndEndRadius: 0
|
|
},
|
|
// range end border-radius
|
|
[`&-in-view${pickerCellCls}-range-end:not(${pickerCellCls}-range-end-single):not(${pickerCellCls}-range-start) ${pickerCellInnerCls}`]: {
|
|
borderStartStartRadius: 0,
|
|
borderEndStartRadius: 0,
|
|
borderStartEndRadius: borderRadiusSM,
|
|
borderEndEndRadius: borderRadiusSM
|
|
},
|
|
[`&-range-hover${pickerCellCls}-range-end::after`]: {
|
|
insetInlineStart: '50%'
|
|
},
|
|
// Edge start
|
|
[`tr > &-in-view${pickerCellCls}-range-hover:first-child::after,
|
|
tr > &-in-view${pickerCellCls}-range-hover-end:first-child::after,
|
|
&-in-view${pickerCellCls}-start${pickerCellCls}-range-hover-edge-start${pickerCellCls}-range-hover-edge-start-near-range::after,
|
|
&-in-view${pickerCellCls}-range-hover-edge-start:not(${pickerCellCls}-range-hover-edge-start-near-range)::after,
|
|
&-in-view${pickerCellCls}-range-hover-start::after`]: {
|
|
insetInlineStart: (cellWidth - cellHeight) / 2,
|
|
borderInlineStart: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
borderStartStartRadius: borderRadiusSM,
|
|
borderEndStartRadius: borderRadiusSM
|
|
},
|
|
// Edge end
|
|
[`tr > &-in-view${pickerCellCls}-range-hover:last-child::after,
|
|
tr > &-in-view${pickerCellCls}-range-hover-start:last-child::after,
|
|
&-in-view${pickerCellCls}-end${pickerCellCls}-range-hover-edge-end${pickerCellCls}-range-hover-edge-end-near-range::after,
|
|
&-in-view${pickerCellCls}-range-hover-edge-end:not(${pickerCellCls}-range-hover-edge-end-near-range)::after,
|
|
&-in-view${pickerCellCls}-range-hover-end::after`]: {
|
|
insetInlineEnd: (cellWidth - cellHeight) / 2,
|
|
borderInlineEnd: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
borderStartEndRadius: borderRadiusSM,
|
|
borderEndEndRadius: borderRadiusSM
|
|
},
|
|
// >>> Disabled
|
|
'&-disabled': {
|
|
color: colorTextDisabled,
|
|
pointerEvents: 'none',
|
|
[pickerCellInnerCls]: {
|
|
background: 'transparent'
|
|
},
|
|
'&::before': {
|
|
background: cellBgDisabled
|
|
}
|
|
},
|
|
[`&-disabled${pickerCellCls}-today ${pickerCellInnerCls}::before`]: {
|
|
borderColor: colorTextDisabled
|
|
}
|
|
};
|
|
};
|
|
const genPanelStyle = token => {
|
|
const {
|
|
componentCls,
|
|
pickerCellCls,
|
|
pickerCellInnerCls,
|
|
pickerYearMonthCellWidth,
|
|
pickerControlIconSize,
|
|
cellWidth,
|
|
paddingSM,
|
|
paddingXS,
|
|
paddingXXS,
|
|
colorBgContainer,
|
|
lineWidth,
|
|
lineType,
|
|
borderRadiusLG,
|
|
colorPrimary,
|
|
colorTextHeading,
|
|
colorSplit,
|
|
pickerControlIconBorderWidth,
|
|
colorIcon,
|
|
textHeight,
|
|
motionDurationMid,
|
|
colorIconHover,
|
|
fontWeightStrong,
|
|
cellHeight,
|
|
pickerCellPaddingVertical,
|
|
colorTextDisabled,
|
|
colorText,
|
|
fontSize,
|
|
cellHoverWithRangeBg,
|
|
motionDurationSlow,
|
|
withoutTimeCellHeight,
|
|
pickerQuarterPanelContentHeight,
|
|
colorLink,
|
|
colorLinkActive,
|
|
colorLinkHover,
|
|
cellRangeBorderColor,
|
|
borderRadiusSM,
|
|
colorTextLightSolid,
|
|
cellHoverBg,
|
|
timeColumnHeight,
|
|
timeColumnWidth,
|
|
timeCellHeight,
|
|
controlItemBgActive,
|
|
marginXXS,
|
|
pickerDatePanelPaddingHorizontal
|
|
} = token;
|
|
const pickerPanelWidth = cellWidth * 7 + pickerDatePanelPaddingHorizontal * 2;
|
|
const commonHoverCellFixedDistance = (pickerPanelWidth - paddingXS * 2) / 3 - pickerYearMonthCellWidth - paddingSM;
|
|
const quarterHoverCellFixedDistance = (pickerPanelWidth - paddingXS * 2) / 4 - pickerYearMonthCellWidth;
|
|
return {
|
|
[componentCls]: {
|
|
'&-panel': {
|
|
display: 'inline-flex',
|
|
flexDirection: 'column',
|
|
textAlign: 'center',
|
|
background: colorBgContainer,
|
|
border: `${lineWidth}px ${lineType} ${colorSplit}`,
|
|
borderRadius: borderRadiusLG,
|
|
outline: 'none',
|
|
'&-focused': {
|
|
borderColor: colorPrimary
|
|
},
|
|
'&-rtl': {
|
|
direction: 'rtl',
|
|
[`${componentCls}-prev-icon,
|
|
${componentCls}-super-prev-icon`]: {
|
|
transform: 'rotate(45deg)'
|
|
},
|
|
[`${componentCls}-next-icon,
|
|
${componentCls}-super-next-icon`]: {
|
|
transform: 'rotate(-135deg)'
|
|
}
|
|
}
|
|
},
|
|
// ========================================================
|
|
// = Shared Panel =
|
|
// ========================================================
|
|
[`&-decade-panel,
|
|
&-year-panel,
|
|
&-quarter-panel,
|
|
&-month-panel,
|
|
&-week-panel,
|
|
&-date-panel,
|
|
&-time-panel`]: {
|
|
display: 'flex',
|
|
flexDirection: 'column',
|
|
width: pickerPanelWidth
|
|
},
|
|
// ======================= Header =======================
|
|
'&-header': {
|
|
display: 'flex',
|
|
padding: `0 ${paddingXS}px`,
|
|
color: colorTextHeading,
|
|
borderBottom: `${lineWidth}px ${lineType} ${colorSplit}`,
|
|
'> *': {
|
|
flex: 'none'
|
|
},
|
|
button: {
|
|
padding: 0,
|
|
color: colorIcon,
|
|
lineHeight: `${textHeight}px`,
|
|
background: 'transparent',
|
|
border: 0,
|
|
cursor: 'pointer',
|
|
transition: `color ${motionDurationMid}`,
|
|
fontSize: 'inherit'
|
|
},
|
|
'> button': {
|
|
minWidth: '1.6em',
|
|
fontSize,
|
|
'&:hover': {
|
|
color: colorIconHover
|
|
}
|
|
},
|
|
'&-view': {
|
|
flex: 'auto',
|
|
fontWeight: fontWeightStrong,
|
|
lineHeight: `${textHeight}px`,
|
|
button: {
|
|
color: 'inherit',
|
|
fontWeight: 'inherit',
|
|
verticalAlign: 'top',
|
|
'&:not(:first-child)': {
|
|
marginInlineStart: paddingXS
|
|
},
|
|
'&:hover': {
|
|
color: colorPrimary
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// Arrow button
|
|
[`&-prev-icon,
|
|
&-next-icon,
|
|
&-super-prev-icon,
|
|
&-super-next-icon`]: {
|
|
position: 'relative',
|
|
display: 'inline-block',
|
|
width: pickerControlIconSize,
|
|
height: pickerControlIconSize,
|
|
'&::before': {
|
|
position: 'absolute',
|
|
top: 0,
|
|
insetInlineStart: 0,
|
|
display: 'inline-block',
|
|
width: pickerControlIconSize,
|
|
height: pickerControlIconSize,
|
|
border: `0 solid currentcolor`,
|
|
borderBlockStartWidth: pickerControlIconBorderWidth,
|
|
borderBlockEndWidth: 0,
|
|
borderInlineStartWidth: pickerControlIconBorderWidth,
|
|
borderInlineEndWidth: 0,
|
|
content: '""'
|
|
}
|
|
},
|
|
[`&-super-prev-icon,
|
|
&-super-next-icon`]: {
|
|
'&::after': {
|
|
position: 'absolute',
|
|
top: Math.ceil(pickerControlIconSize / 2),
|
|
insetInlineStart: Math.ceil(pickerControlIconSize / 2),
|
|
display: 'inline-block',
|
|
width: pickerControlIconSize,
|
|
height: pickerControlIconSize,
|
|
border: '0 solid currentcolor',
|
|
borderBlockStartWidth: pickerControlIconBorderWidth,
|
|
borderBlockEndWidth: 0,
|
|
borderInlineStartWidth: pickerControlIconBorderWidth,
|
|
borderInlineEndWidth: 0,
|
|
content: '""'
|
|
}
|
|
},
|
|
[`&-prev-icon,
|
|
&-super-prev-icon`]: {
|
|
transform: 'rotate(-45deg)'
|
|
},
|
|
[`&-next-icon,
|
|
&-super-next-icon`]: {
|
|
transform: 'rotate(135deg)'
|
|
},
|
|
// ======================== Body ========================
|
|
'&-content': {
|
|
width: '100%',
|
|
tableLayout: 'fixed',
|
|
borderCollapse: 'collapse',
|
|
'th, td': {
|
|
position: 'relative',
|
|
minWidth: cellHeight,
|
|
fontWeight: 'normal'
|
|
},
|
|
th: {
|
|
height: cellHeight + pickerCellPaddingVertical * 2,
|
|
color: colorText,
|
|
verticalAlign: 'middle'
|
|
}
|
|
},
|
|
'&-cell': Object.assign({
|
|
padding: `${pickerCellPaddingVertical}px 0`,
|
|
color: colorTextDisabled,
|
|
cursor: 'pointer',
|
|
// In view
|
|
'&-in-view': {
|
|
color: colorText
|
|
}
|
|
}, genPickerCellInnerStyle(token)),
|
|
// DatePanel only
|
|
[`&-date-panel ${componentCls}-cell-in-view${componentCls}-cell-in-range${componentCls}-cell-range-hover-start ${pickerCellInnerCls},
|
|
&-date-panel ${componentCls}-cell-in-view${componentCls}-cell-in-range${componentCls}-cell-range-hover-end ${pickerCellInnerCls}`]: {
|
|
'&::after': {
|
|
position: 'absolute',
|
|
top: 0,
|
|
bottom: 0,
|
|
zIndex: -1,
|
|
background: cellHoverWithRangeBg,
|
|
transition: `all ${motionDurationSlow}`,
|
|
content: '""'
|
|
}
|
|
},
|
|
[`&-date-panel
|
|
${componentCls}-cell-in-view${componentCls}-cell-in-range${componentCls}-cell-range-hover-start
|
|
${pickerCellInnerCls}::after`]: {
|
|
insetInlineEnd: -(cellWidth - cellHeight) / 2,
|
|
insetInlineStart: 0
|
|
},
|
|
[`&-date-panel ${componentCls}-cell-in-view${componentCls}-cell-in-range${componentCls}-cell-range-hover-end ${pickerCellInnerCls}::after`]: {
|
|
insetInlineEnd: 0,
|
|
insetInlineStart: -(cellWidth - cellHeight) / 2
|
|
},
|
|
// Hover with range start & end
|
|
[`&-range-hover${componentCls}-range-start::after`]: {
|
|
insetInlineEnd: '50%'
|
|
},
|
|
[`&-decade-panel,
|
|
&-year-panel,
|
|
&-quarter-panel,
|
|
&-month-panel`]: {
|
|
[`${componentCls}-content`]: {
|
|
height: withoutTimeCellHeight * 4
|
|
},
|
|
[pickerCellInnerCls]: {
|
|
padding: `0 ${paddingXS}px`
|
|
}
|
|
},
|
|
'&-quarter-panel': {
|
|
[`${componentCls}-content`]: {
|
|
height: pickerQuarterPanelContentHeight
|
|
},
|
|
// Quarter Panel Special Style
|
|
[`${componentCls}-cell-range-hover-start::after`]: {
|
|
insetInlineStart: quarterHoverCellFixedDistance,
|
|
borderInlineStart: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineEnd: quarterHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${cellRangeBorderColor}`
|
|
}
|
|
},
|
|
[`${componentCls}-cell-range-hover-end::after`]: {
|
|
insetInlineEnd: quarterHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineStart: quarterHoverCellFixedDistance,
|
|
borderInlineStart: `${lineWidth}px dashed ${cellRangeBorderColor}`
|
|
}
|
|
}
|
|
},
|
|
// ======================== Footer ========================
|
|
[`&-panel ${componentCls}-footer`]: {
|
|
borderTop: `${lineWidth}px ${lineType} ${colorSplit}`
|
|
},
|
|
'&-footer': {
|
|
width: 'min-content',
|
|
minWidth: '100%',
|
|
lineHeight: `${textHeight - 2 * lineWidth}px`,
|
|
textAlign: 'center',
|
|
'&-extra': {
|
|
padding: `0 ${paddingSM}px`,
|
|
lineHeight: `${textHeight - 2 * lineWidth}px`,
|
|
textAlign: 'start',
|
|
'&:not(:last-child)': {
|
|
borderBottom: `${lineWidth}px ${lineType} ${colorSplit}`
|
|
}
|
|
}
|
|
},
|
|
'&-now': {
|
|
textAlign: 'start'
|
|
},
|
|
'&-today-btn': {
|
|
color: colorLink,
|
|
'&:hover': {
|
|
color: colorLinkHover
|
|
},
|
|
'&:active': {
|
|
color: colorLinkActive
|
|
},
|
|
[`&${componentCls}-today-btn-disabled`]: {
|
|
color: colorTextDisabled,
|
|
cursor: 'not-allowed'
|
|
}
|
|
},
|
|
// ========================================================
|
|
// = Special =
|
|
// ========================================================
|
|
// ===================== Decade Panel =====================
|
|
'&-decade-panel': {
|
|
[pickerCellInnerCls]: {
|
|
padding: `0 ${paddingXS / 2}px`
|
|
},
|
|
[`${componentCls}-cell::before`]: {
|
|
display: 'none'
|
|
}
|
|
},
|
|
// ============= Year & Quarter & Month Panel =============
|
|
[`&-year-panel,
|
|
&-quarter-panel,
|
|
&-month-panel`]: {
|
|
[`${componentCls}-body`]: {
|
|
padding: `0 ${paddingXS}px`
|
|
},
|
|
[pickerCellInnerCls]: {
|
|
width: pickerYearMonthCellWidth
|
|
},
|
|
[`${componentCls}-cell-range-hover-start::after`]: {
|
|
borderStartStartRadius: borderRadiusSM,
|
|
borderEndStartRadius: borderRadiusSM,
|
|
borderStartEndRadius: 0,
|
|
borderEndEndRadius: 0,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
borderStartStartRadius: 0,
|
|
borderEndStartRadius: 0,
|
|
borderStartEndRadius: borderRadiusSM,
|
|
borderEndEndRadius: borderRadiusSM
|
|
}
|
|
},
|
|
[`${componentCls}-cell-range-hover-end::after`]: {
|
|
borderStartStartRadius: 0,
|
|
borderEndStartRadius: 0,
|
|
borderStartEndRadius: borderRadiusSM,
|
|
borderEndEndRadius: borderRadiusSM,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
borderStartStartRadius: borderRadiusSM,
|
|
borderEndStartRadius: borderRadiusSM,
|
|
borderStartEndRadius: 0,
|
|
borderEndEndRadius: 0
|
|
}
|
|
}
|
|
},
|
|
[`&-year-panel,
|
|
&-month-panel`]: {
|
|
[`${componentCls}-cell-range-hover-start::after`]: {
|
|
insetInlineStart: commonHoverCellFixedDistance,
|
|
borderInlineStart: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineEnd: commonHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${cellRangeBorderColor}`
|
|
}
|
|
},
|
|
[`${componentCls}-cell-range-hover-end::after`]: {
|
|
insetInlineEnd: commonHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${cellRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineStart: commonHoverCellFixedDistance,
|
|
borderInlineStart: `${lineWidth}px dashed ${cellRangeBorderColor}`
|
|
}
|
|
}
|
|
},
|
|
// ====================== Week Panel ======================
|
|
'&-week-panel': {
|
|
[`${componentCls}-body`]: {
|
|
padding: `${paddingXS}px ${paddingSM}px`
|
|
},
|
|
// Clear cell style
|
|
[`${componentCls}-cell`]: {
|
|
[`&:hover ${pickerCellInnerCls},
|
|
&-selected ${pickerCellInnerCls},
|
|
${pickerCellInnerCls}`]: {
|
|
background: 'transparent !important'
|
|
}
|
|
},
|
|
'&-row': {
|
|
td: {
|
|
'&:before': {
|
|
transition: `background ${motionDurationMid}`
|
|
},
|
|
'&:first-child:before': {
|
|
borderStartStartRadius: borderRadiusSM,
|
|
borderEndStartRadius: borderRadiusSM
|
|
},
|
|
'&:last-child:before': {
|
|
borderStartEndRadius: borderRadiusSM,
|
|
borderEndEndRadius: borderRadiusSM
|
|
}
|
|
},
|
|
[`&:hover td`]: {
|
|
'&:before': {
|
|
background: cellHoverBg
|
|
}
|
|
},
|
|
[`&-range-start td,
|
|
&-range-end td,
|
|
&-selected td`]: {
|
|
// Rise priority to override hover style
|
|
[`&${pickerCellCls}`]: {
|
|
'&:before': {
|
|
background: colorPrimary
|
|
},
|
|
[`&${componentCls}-cell-week`]: {
|
|
color: new dist_module/* TinyColor */.C(colorTextLightSolid).setAlpha(0.5).toHexString()
|
|
},
|
|
[pickerCellInnerCls]: {
|
|
color: colorTextLightSolid
|
|
}
|
|
}
|
|
},
|
|
[`&-range-hover td:before`]: {
|
|
background: controlItemBgActive
|
|
}
|
|
}
|
|
},
|
|
// ====================== Date Panel ======================
|
|
'&-date-panel': {
|
|
[`${componentCls}-body`]: {
|
|
padding: `${paddingXS}px ${pickerDatePanelPaddingHorizontal}px`
|
|
},
|
|
[`${componentCls}-content`]: {
|
|
width: cellWidth * 7,
|
|
th: {
|
|
width: cellWidth,
|
|
boxSizing: 'border-box',
|
|
padding: 0
|
|
}
|
|
}
|
|
},
|
|
// ==================== Datetime Panel ====================
|
|
'&-datetime-panel': {
|
|
display: 'flex',
|
|
[`${componentCls}-time-panel`]: {
|
|
borderInlineStart: `${lineWidth}px ${lineType} ${colorSplit}`
|
|
},
|
|
[`${componentCls}-date-panel,
|
|
${componentCls}-time-panel`]: {
|
|
transition: `opacity ${motionDurationSlow}`
|
|
},
|
|
// Keyboard
|
|
'&-active': {
|
|
[`${componentCls}-date-panel,
|
|
${componentCls}-time-panel`]: {
|
|
opacity: 0.3,
|
|
'&-active': {
|
|
opacity: 1
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// ====================== Time Panel ======================
|
|
'&-time-panel': {
|
|
width: 'auto',
|
|
minWidth: 'auto',
|
|
direction: 'ltr',
|
|
[`${componentCls}-content`]: {
|
|
display: 'flex',
|
|
flex: 'auto',
|
|
height: timeColumnHeight
|
|
},
|
|
'&-column': {
|
|
flex: '1 0 auto',
|
|
width: timeColumnWidth,
|
|
margin: `${paddingXXS}px 0`,
|
|
padding: 0,
|
|
overflowY: 'hidden',
|
|
textAlign: 'start',
|
|
listStyle: 'none',
|
|
transition: `background ${motionDurationMid}`,
|
|
overflowX: 'hidden',
|
|
'&::after': {
|
|
display: 'block',
|
|
height: timeColumnHeight - timeCellHeight,
|
|
content: '""'
|
|
},
|
|
'&:not(:first-child)': {
|
|
borderInlineStart: `${lineWidth}px ${lineType} ${colorSplit}`
|
|
},
|
|
'&-active': {
|
|
background: new dist_module/* TinyColor */.C(controlItemBgActive).setAlpha(0.2).toHexString()
|
|
},
|
|
'&:hover': {
|
|
overflowY: 'auto'
|
|
},
|
|
'> li': {
|
|
margin: 0,
|
|
padding: 0,
|
|
[`&${componentCls}-time-panel-cell`]: {
|
|
marginInline: marginXXS,
|
|
[`${componentCls}-time-panel-cell-inner`]: {
|
|
display: 'block',
|
|
width: timeColumnWidth - 2 * marginXXS,
|
|
height: timeCellHeight,
|
|
margin: 0,
|
|
paddingBlock: 0,
|
|
paddingInlineEnd: 0,
|
|
paddingInlineStart: (timeColumnWidth - timeCellHeight) / 2,
|
|
color: colorText,
|
|
lineHeight: `${timeCellHeight}px`,
|
|
borderRadius: borderRadiusSM,
|
|
cursor: 'pointer',
|
|
transition: `background ${motionDurationMid}`,
|
|
'&:hover': {
|
|
background: cellHoverBg
|
|
}
|
|
},
|
|
'&-selected': {
|
|
[`${componentCls}-time-panel-cell-inner`]: {
|
|
background: controlItemBgActive
|
|
}
|
|
},
|
|
'&-disabled': {
|
|
[`${componentCls}-time-panel-cell-inner`]: {
|
|
color: colorTextDisabled,
|
|
background: 'transparent',
|
|
cursor: 'not-allowed'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// https://github.com/ant-design/ant-design/issues/39227
|
|
[`&-datetime-panel ${componentCls}-time-panel-column:after`]: {
|
|
height: timeColumnHeight - timeCellHeight + paddingXXS * 2
|
|
}
|
|
}
|
|
};
|
|
};
|
|
const genPickerStatusStyle = token => {
|
|
const {
|
|
componentCls,
|
|
colorBgContainer,
|
|
colorError,
|
|
errorActiveShadow,
|
|
colorWarning,
|
|
warningActiveShadow
|
|
} = token;
|
|
return {
|
|
[`${componentCls}:not(${componentCls}-disabled)`]: {
|
|
[`&${componentCls}-status-error`]: {
|
|
'&, &:not([disabled]):hover': {
|
|
backgroundColor: colorBgContainer,
|
|
borderColor: colorError
|
|
},
|
|
[`&${componentCls}-focused, &:focus`]: Object.assign({}, (0,input_style/* genActiveStyle */.M1)((0,statistic/* merge */.TS)(token, {
|
|
activeBorderColor: colorError,
|
|
activeShadow: errorActiveShadow
|
|
}))),
|
|
[`${componentCls}-active-bar`]: {
|
|
background: colorError
|
|
}
|
|
},
|
|
[`&${componentCls}-status-warning`]: {
|
|
'&, &:not([disabled]):hover': {
|
|
backgroundColor: colorBgContainer,
|
|
borderColor: colorWarning
|
|
},
|
|
[`&${componentCls}-focused, &:focus`]: Object.assign({}, (0,input_style/* genActiveStyle */.M1)((0,statistic/* merge */.TS)(token, {
|
|
activeBorderColor: colorWarning,
|
|
activeShadow: warningActiveShadow
|
|
}))),
|
|
[`${componentCls}-active-bar`]: {
|
|
background: colorWarning
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
const genPickerStyle = token => {
|
|
const {
|
|
componentCls,
|
|
antCls,
|
|
controlHeight,
|
|
fontSize,
|
|
paddingInline,
|
|
colorBgContainer,
|
|
lineWidth,
|
|
lineType,
|
|
colorBorder,
|
|
borderRadius,
|
|
motionDurationMid,
|
|
colorBgContainerDisabled,
|
|
colorTextDisabled,
|
|
colorTextPlaceholder,
|
|
controlHeightLG,
|
|
fontSizeLG,
|
|
controlHeightSM,
|
|
paddingInlineSM,
|
|
paddingXS,
|
|
marginXS,
|
|
colorTextDescription,
|
|
lineWidthBold,
|
|
lineHeight,
|
|
colorPrimary,
|
|
motionDurationSlow,
|
|
zIndexPopup,
|
|
paddingXXS,
|
|
paddingSM,
|
|
textHeight,
|
|
cellActiveWithRangeBg,
|
|
colorPrimaryBorder,
|
|
sizePopupArrow,
|
|
borderRadiusXS,
|
|
borderRadiusOuter,
|
|
colorBgElevated,
|
|
borderRadiusLG,
|
|
boxShadowSecondary,
|
|
borderRadiusSM,
|
|
colorSplit,
|
|
cellHoverBg,
|
|
presetsWidth,
|
|
presetsMaxWidth,
|
|
boxShadowPopoverArrow,
|
|
colorTextQuaternary
|
|
} = token;
|
|
return [{
|
|
[componentCls]: Object.assign(Object.assign(Object.assign({}, (0,es_style/* resetComponent */.Wf)(token)), genPikerPadding(token, controlHeight, fontSize, paddingInline)), {
|
|
position: 'relative',
|
|
display: 'inline-flex',
|
|
alignItems: 'center',
|
|
background: colorBgContainer,
|
|
lineHeight: 1,
|
|
border: `${lineWidth}px ${lineType} ${colorBorder}`,
|
|
borderRadius,
|
|
transition: `border ${motionDurationMid}, box-shadow ${motionDurationMid}`,
|
|
'&:hover, &-focused': Object.assign({}, (0,input_style/* genHoverStyle */.pU)(token)),
|
|
'&-focused': Object.assign({}, (0,input_style/* genActiveStyle */.M1)(token)),
|
|
[`&${componentCls}-disabled`]: {
|
|
background: colorBgContainerDisabled,
|
|
borderColor: colorBorder,
|
|
cursor: 'not-allowed',
|
|
[`${componentCls}-suffix`]: {
|
|
color: colorTextQuaternary
|
|
}
|
|
},
|
|
[`&${componentCls}-borderless`]: {
|
|
backgroundColor: 'transparent !important',
|
|
borderColor: 'transparent !important',
|
|
boxShadow: 'none !important'
|
|
},
|
|
// ======================== Input =========================
|
|
[`${componentCls}-input`]: {
|
|
position: 'relative',
|
|
display: 'inline-flex',
|
|
alignItems: 'center',
|
|
width: '100%',
|
|
'> input': Object.assign(Object.assign({}, (0,input_style/* genBasicInputStyle */.ik)(token)), {
|
|
flex: 'auto',
|
|
// Fix Firefox flex not correct:
|
|
// https://github.com/ant-design/ant-design/pull/20023#issuecomment-564389553
|
|
minWidth: 1,
|
|
height: 'auto',
|
|
padding: 0,
|
|
background: 'transparent',
|
|
border: 0,
|
|
borderRadius: 0,
|
|
'&:focus': {
|
|
boxShadow: 'none'
|
|
},
|
|
'&[disabled]': {
|
|
background: 'transparent'
|
|
}
|
|
}),
|
|
'&:hover': {
|
|
[`${componentCls}-clear`]: {
|
|
opacity: 1
|
|
}
|
|
},
|
|
'&-placeholder': {
|
|
'> input': {
|
|
color: colorTextPlaceholder
|
|
}
|
|
}
|
|
},
|
|
// Size
|
|
'&-large': Object.assign(Object.assign({}, genPikerPadding(token, controlHeightLG, fontSizeLG, paddingInline)), {
|
|
[`${componentCls}-input > input`]: {
|
|
fontSize: fontSizeLG
|
|
}
|
|
}),
|
|
'&-small': Object.assign({}, genPikerPadding(token, controlHeightSM, fontSize, paddingInlineSM)),
|
|
[`${componentCls}-suffix`]: {
|
|
display: 'flex',
|
|
flex: 'none',
|
|
alignSelf: 'center',
|
|
marginInlineStart: paddingXS / 2,
|
|
color: colorTextDisabled,
|
|
lineHeight: 1,
|
|
pointerEvents: 'none',
|
|
'> *': {
|
|
verticalAlign: 'top',
|
|
'&:not(:last-child)': {
|
|
marginInlineEnd: marginXS
|
|
}
|
|
}
|
|
},
|
|
[`${componentCls}-clear`]: {
|
|
position: 'absolute',
|
|
top: '50%',
|
|
insetInlineEnd: 0,
|
|
color: colorTextDisabled,
|
|
lineHeight: 1,
|
|
background: colorBgContainer,
|
|
transform: 'translateY(-50%)',
|
|
cursor: 'pointer',
|
|
opacity: 0,
|
|
transition: `opacity ${motionDurationMid}, color ${motionDurationMid}`,
|
|
'> *': {
|
|
verticalAlign: 'top'
|
|
},
|
|
'&:hover': {
|
|
color: colorTextDescription
|
|
}
|
|
},
|
|
[`${componentCls}-separator`]: {
|
|
position: 'relative',
|
|
display: 'inline-block',
|
|
width: '1em',
|
|
height: fontSizeLG,
|
|
color: colorTextDisabled,
|
|
fontSize: fontSizeLG,
|
|
verticalAlign: 'top',
|
|
cursor: 'default',
|
|
[`${componentCls}-focused &`]: {
|
|
color: colorTextDescription
|
|
},
|
|
[`${componentCls}-range-separator &`]: {
|
|
[`${componentCls}-disabled &`]: {
|
|
cursor: 'not-allowed'
|
|
}
|
|
}
|
|
},
|
|
// ======================== Range =========================
|
|
'&-range': {
|
|
position: 'relative',
|
|
display: 'inline-flex',
|
|
// Clear
|
|
[`${componentCls}-clear`]: {
|
|
insetInlineEnd: paddingInline
|
|
},
|
|
'&:hover': {
|
|
[`${componentCls}-clear`]: {
|
|
opacity: 1
|
|
}
|
|
},
|
|
// Active bar
|
|
[`${componentCls}-active-bar`]: {
|
|
bottom: -lineWidth,
|
|
height: lineWidthBold,
|
|
marginInlineStart: paddingInline,
|
|
background: colorPrimary,
|
|
opacity: 0,
|
|
transition: `all ${motionDurationSlow} ease-out`,
|
|
pointerEvents: 'none'
|
|
},
|
|
[`&${componentCls}-focused`]: {
|
|
[`${componentCls}-active-bar`]: {
|
|
opacity: 1
|
|
}
|
|
},
|
|
[`${componentCls}-range-separator`]: {
|
|
alignItems: 'center',
|
|
padding: `0 ${paddingXS}px`,
|
|
lineHeight: 1
|
|
},
|
|
[`&${componentCls}-small`]: {
|
|
[`${componentCls}-clear`]: {
|
|
insetInlineEnd: paddingInlineSM
|
|
},
|
|
[`${componentCls}-active-bar`]: {
|
|
marginInlineStart: paddingInlineSM
|
|
}
|
|
}
|
|
},
|
|
// ======================= Dropdown =======================
|
|
'&-dropdown': Object.assign(Object.assign(Object.assign({}, (0,es_style/* resetComponent */.Wf)(token)), genPanelStyle(token)), {
|
|
position: 'absolute',
|
|
// Fix incorrect position of picker popup
|
|
// https://github.com/ant-design/ant-design/issues/35590
|
|
top: -9999,
|
|
left: {
|
|
_skip_check_: true,
|
|
value: -9999
|
|
},
|
|
zIndex: zIndexPopup,
|
|
[`&${componentCls}-dropdown-hidden`]: {
|
|
display: 'none'
|
|
},
|
|
[`&${componentCls}-dropdown-placement-bottomLeft`]: {
|
|
[`${componentCls}-range-arrow`]: {
|
|
top: 0,
|
|
display: 'block',
|
|
transform: 'translateY(-100%)'
|
|
}
|
|
},
|
|
[`&${componentCls}-dropdown-placement-topLeft`]: {
|
|
[`${componentCls}-range-arrow`]: {
|
|
bottom: 0,
|
|
display: 'block',
|
|
transform: 'translateY(100%) rotate(180deg)'
|
|
}
|
|
},
|
|
[`&${antCls}-slide-up-enter${antCls}-slide-up-enter-active${componentCls}-dropdown-placement-topLeft,
|
|
&${antCls}-slide-up-enter${antCls}-slide-up-enter-active${componentCls}-dropdown-placement-topRight,
|
|
&${antCls}-slide-up-appear${antCls}-slide-up-appear-active${componentCls}-dropdown-placement-topLeft,
|
|
&${antCls}-slide-up-appear${antCls}-slide-up-appear-active${componentCls}-dropdown-placement-topRight`]: {
|
|
animationName: slide/* slideDownIn */.Qt
|
|
},
|
|
[`&${antCls}-slide-up-enter${antCls}-slide-up-enter-active${componentCls}-dropdown-placement-bottomLeft,
|
|
&${antCls}-slide-up-enter${antCls}-slide-up-enter-active${componentCls}-dropdown-placement-bottomRight,
|
|
&${antCls}-slide-up-appear${antCls}-slide-up-appear-active${componentCls}-dropdown-placement-bottomLeft,
|
|
&${antCls}-slide-up-appear${antCls}-slide-up-appear-active${componentCls}-dropdown-placement-bottomRight`]: {
|
|
animationName: slide/* slideUpIn */.fJ
|
|
},
|
|
[`&${antCls}-slide-up-leave${antCls}-slide-up-leave-active${componentCls}-dropdown-placement-topLeft,
|
|
&${antCls}-slide-up-leave${antCls}-slide-up-leave-active${componentCls}-dropdown-placement-topRight`]: {
|
|
animationName: slide/* slideDownOut */.ly
|
|
},
|
|
[`&${antCls}-slide-up-leave${antCls}-slide-up-leave-active${componentCls}-dropdown-placement-bottomLeft,
|
|
&${antCls}-slide-up-leave${antCls}-slide-up-leave-active${componentCls}-dropdown-placement-bottomRight`]: {
|
|
animationName: slide/* slideUpOut */.Uw
|
|
},
|
|
// Time picker with additional style
|
|
[`${componentCls}-panel > ${componentCls}-time-panel`]: {
|
|
paddingTop: paddingXXS
|
|
},
|
|
// ======================== Ranges ========================
|
|
[`${componentCls}-ranges`]: {
|
|
marginBottom: 0,
|
|
padding: `${paddingXXS}px ${paddingSM}px`,
|
|
overflow: 'hidden',
|
|
lineHeight: `${textHeight - 2 * lineWidth - paddingXS / 2}px`,
|
|
textAlign: 'start',
|
|
listStyle: 'none',
|
|
display: 'flex',
|
|
justifyContent: 'space-between',
|
|
'> li': {
|
|
display: 'inline-block'
|
|
},
|
|
// https://github.com/ant-design/ant-design/issues/23687
|
|
[`${componentCls}-preset > ${antCls}-tag-blue`]: {
|
|
color: colorPrimary,
|
|
background: cellActiveWithRangeBg,
|
|
borderColor: colorPrimaryBorder,
|
|
cursor: 'pointer'
|
|
},
|
|
[`${componentCls}-ok`]: {
|
|
marginInlineStart: 'auto'
|
|
}
|
|
},
|
|
[`${componentCls}-range-wrapper`]: {
|
|
display: 'flex',
|
|
position: 'relative'
|
|
},
|
|
[`${componentCls}-range-arrow`]: Object.assign({
|
|
position: 'absolute',
|
|
zIndex: 1,
|
|
display: 'none',
|
|
marginInlineStart: paddingInline * 1.5,
|
|
transition: `left ${motionDurationSlow} ease-out`
|
|
}, (0,roundedArrow/* roundedArrow */.r)(sizePopupArrow, borderRadiusXS, borderRadiusOuter, colorBgElevated, boxShadowPopoverArrow)),
|
|
[`${componentCls}-panel-container`]: {
|
|
overflow: 'hidden',
|
|
verticalAlign: 'top',
|
|
background: colorBgElevated,
|
|
borderRadius: borderRadiusLG,
|
|
boxShadow: boxShadowSecondary,
|
|
transition: `margin ${motionDurationSlow}`,
|
|
// ======================== Layout ========================
|
|
[`${componentCls}-panel-layout`]: {
|
|
display: 'flex',
|
|
flexWrap: 'nowrap',
|
|
alignItems: 'stretch'
|
|
},
|
|
// ======================== Preset ========================
|
|
[`${componentCls}-presets`]: {
|
|
display: 'flex',
|
|
flexDirection: 'column',
|
|
minWidth: presetsWidth,
|
|
maxWidth: presetsMaxWidth,
|
|
ul: {
|
|
height: 0,
|
|
flex: 'auto',
|
|
listStyle: 'none',
|
|
overflow: 'auto',
|
|
margin: 0,
|
|
padding: paddingXS,
|
|
borderInlineEnd: `${lineWidth}px ${lineType} ${colorSplit}`,
|
|
li: Object.assign(Object.assign({}, es_style/* textEllipsis */.vS), {
|
|
borderRadius: borderRadiusSM,
|
|
paddingInline: paddingXS,
|
|
paddingBlock: (controlHeightSM - Math.round(fontSize * lineHeight)) / 2,
|
|
cursor: 'pointer',
|
|
transition: `all ${motionDurationSlow}`,
|
|
'+ li': {
|
|
marginTop: marginXS
|
|
},
|
|
'&:hover': {
|
|
background: cellHoverBg
|
|
}
|
|
})
|
|
}
|
|
},
|
|
// ======================== Panels ========================
|
|
[`${componentCls}-panels`]: {
|
|
display: 'inline-flex',
|
|
flexWrap: 'nowrap',
|
|
direction: 'ltr',
|
|
[`${componentCls}-panel`]: {
|
|
borderWidth: `0 0 ${lineWidth}px`
|
|
},
|
|
'&:last-child': {
|
|
[`${componentCls}-panel`]: {
|
|
borderWidth: 0
|
|
}
|
|
}
|
|
},
|
|
[`${componentCls}-panel`]: {
|
|
verticalAlign: 'top',
|
|
background: 'transparent',
|
|
borderRadius: 0,
|
|
borderWidth: 0,
|
|
[`${componentCls}-content,
|
|
table`]: {
|
|
textAlign: 'center'
|
|
},
|
|
'&-focused': {
|
|
borderColor: colorBorder
|
|
}
|
|
}
|
|
}
|
|
}),
|
|
'&-dropdown-range': {
|
|
padding: `${sizePopupArrow * 2 / 3}px 0`,
|
|
'&-hidden': {
|
|
display: 'none'
|
|
}
|
|
},
|
|
'&-rtl': {
|
|
direction: 'rtl',
|
|
[`${componentCls}-separator`]: {
|
|
transform: 'rotate(180deg)'
|
|
},
|
|
[`${componentCls}-footer`]: {
|
|
'&-extra': {
|
|
direction: 'rtl'
|
|
}
|
|
}
|
|
}
|
|
})
|
|
},
|
|
// Follow code may reuse in other components
|
|
(0,slide/* initSlideMotion */.oN)(token, 'slide-up'), (0,slide/* initSlideMotion */.oN)(token, 'slide-down'), (0,move/* initMoveMotion */.Fm)(token, 'move-up'), (0,move/* initMoveMotion */.Fm)(token, 'move-down')];
|
|
};
|
|
const initPickerPanelToken = token => {
|
|
const {
|
|
componentCls,
|
|
controlHeightLG,
|
|
paddingXXS,
|
|
padding
|
|
} = token;
|
|
return {
|
|
pickerCellCls: `${componentCls}-cell`,
|
|
pickerCellInnerCls: `${componentCls}-cell-inner`,
|
|
pickerYearMonthCellWidth: controlHeightLG * 1.5,
|
|
pickerQuarterPanelContentHeight: controlHeightLG * 1.4,
|
|
pickerCellPaddingVertical: paddingXXS + paddingXXS / 2,
|
|
pickerCellBorderGap: 2,
|
|
pickerControlIconSize: 7,
|
|
pickerControlIconBorderWidth: 1.5,
|
|
pickerDatePanelPaddingHorizontal: padding + paddingXXS / 2 // 18 in normal
|
|
};
|
|
};
|
|
|
|
const initPanelComponentToken = token => ({
|
|
cellHoverBg: token.controlItemBgHover,
|
|
cellActiveWithRangeBg: token.controlItemBgActive,
|
|
cellHoverWithRangeBg: new dist_module/* TinyColor */.C(token.colorPrimary).lighten(35).toHexString(),
|
|
cellRangeBorderColor: new dist_module/* TinyColor */.C(token.colorPrimary).lighten(20).toHexString(),
|
|
cellBgDisabled: token.colorBgContainerDisabled,
|
|
timeColumnWidth: token.controlHeightLG * 1.4,
|
|
timeColumnHeight: 28 * 8,
|
|
timeCellHeight: 28,
|
|
cellWidth: token.controlHeightSM * 1.5,
|
|
cellHeight: token.controlHeightSM,
|
|
textHeight: token.controlHeightLG,
|
|
withoutTimeCellHeight: token.controlHeightLG * 1.65
|
|
});
|
|
// ============================== Export ==============================
|
|
/* harmony default export */ var date_picker_style = ((0,genComponentStyleHook/* default */.Z)('DatePicker', token => {
|
|
const pickerToken = (0,statistic/* merge */.TS)((0,input_style/* initInputToken */.e5)(token), initPickerPanelToken(token));
|
|
return [genPickerStyle(pickerToken), genPickerStatusStyle(pickerToken),
|
|
// =====================================================
|
|
// == Space Compact ==
|
|
// =====================================================
|
|
(0,compact_item/* genCompactItemStyle */.c)(token, {
|
|
focusElCls: `${token.componentCls}-focused`
|
|
})];
|
|
}, token => Object.assign(Object.assign(Object.assign({}, (0,input_style/* initComponentToken */.TM)(token)), initPanelComponentToken(token)), {
|
|
presetsWidth: 120,
|
|
presetsMaxWidth: 200,
|
|
zIndexPopup: token.zIndexPopupBase + 50
|
|
})));
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/util.js
|
|
function getPlaceholder(locale, picker, 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(locale, picker, 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) {
|
|
const overflow = {
|
|
adjustX: 1,
|
|
adjustY: 1
|
|
};
|
|
switch (placement) {
|
|
case 'bottomLeft':
|
|
{
|
|
return {
|
|
points: ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow
|
|
};
|
|
}
|
|
case 'bottomRight':
|
|
{
|
|
return {
|
|
points: ['tr', 'br'],
|
|
offset: [0, 4],
|
|
overflow
|
|
};
|
|
}
|
|
case 'topLeft':
|
|
{
|
|
return {
|
|
points: ['bl', 'tl'],
|
|
offset: [0, -4],
|
|
overflow
|
|
};
|
|
}
|
|
case 'topRight':
|
|
{
|
|
return {
|
|
points: ['br', 'tr'],
|
|
offset: [0, -4],
|
|
overflow
|
|
};
|
|
}
|
|
default:
|
|
{
|
|
return {
|
|
points: direction === 'rtl' ? ['tr', 'br'] : ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow
|
|
};
|
|
}
|
|
}
|
|
}
|
|
function util_toArray(list) {
|
|
if (!list) {
|
|
return [];
|
|
}
|
|
return Array.isArray(list) ? list : [list];
|
|
}
|
|
function getTimeProps(props) {
|
|
const {
|
|
format,
|
|
picker,
|
|
showHour,
|
|
showMinute,
|
|
showSecond,
|
|
use12Hours
|
|
} = props;
|
|
const firstFormat = util_toArray(format)[0];
|
|
const showTimeObj = Object.assign({}, props);
|
|
// https://github.com/ant-design/ant-design/issues/44275
|
|
if (format && Array.isArray(format)) {
|
|
showTimeObj.format = firstFormat;
|
|
}
|
|
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') && !firstFormat.includes('K') && !firstFormat.includes('k') && 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
|
|
};
|
|
}
|
|
function mergeAllowClear(allowClear, clearIcon, defaultClearIcon) {
|
|
if (allowClear === false) {
|
|
return false;
|
|
}
|
|
const defaults = {
|
|
clearIcon: clearIcon !== null && clearIcon !== void 0 ? clearIcon : defaultClearIcon
|
|
};
|
|
return typeof allowClear === 'object' ? Object.assign(Object.assign({}, defaults), allowClear) : defaults;
|
|
}
|
|
// 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
|
|
"use client";
|
|
|
|
|
|
|
|
function PickerButton(props) {
|
|
return /*#__PURE__*/react.createElement(es_button/* default */.ZP, Object.assign({
|
|
size: "small",
|
|
type: "primary"
|
|
}, props));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/Components.js
|
|
|
|
const Components = {
|
|
button: PickerButton
|
|
};
|
|
/* harmony default export */ var generatePicker_Components = (Components);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/generateRangePicker.js
|
|
"use client";
|
|
|
|
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) {
|
|
const RangePicker = /*#__PURE__*/(0,react.forwardRef)((props, ref) => {
|
|
const {
|
|
prefixCls: customizePrefixCls,
|
|
getPopupContainer: customGetPopupContainer,
|
|
className,
|
|
placement,
|
|
size: customizeSize,
|
|
disabled: customDisabled,
|
|
bordered = true,
|
|
placeholder,
|
|
popupClassName,
|
|
dropdownClassName,
|
|
status: customStatus,
|
|
clearIcon,
|
|
allowClear,
|
|
rootClassName
|
|
} = props,
|
|
restProps = __rest(props, ["prefixCls", "getPopupContainer", "className", "placement", "size", "disabled", "bordered", "placeholder", "popupClassName", "dropdownClassName", "status", "clearIcon", "allowClear", "rootClassName"]);
|
|
const innerRef = react.useRef(null);
|
|
const {
|
|
getPrefixCls,
|
|
direction,
|
|
getPopupContainer
|
|
} = (0,react.useContext)(context/* ConfigContext */.E_);
|
|
const prefixCls = getPrefixCls('picker', customizePrefixCls);
|
|
const {
|
|
compactSize,
|
|
compactItemClassnames
|
|
} = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction);
|
|
const {
|
|
format,
|
|
showTime,
|
|
picker
|
|
} = props;
|
|
const rootPrefixCls = getPrefixCls();
|
|
const [wrapSSR, hashId] = date_picker_style(prefixCls);
|
|
const additionalOverrideProps = Object.assign(Object.assign({}, showTime ? getTimeProps(Object.assign({
|
|
format,
|
|
picker
|
|
}, showTime)) : {}), picker === 'time' ? getTimeProps(Object.assign(Object.assign({
|
|
format
|
|
}, props), {
|
|
picker
|
|
})) : {});
|
|
// =================== Warning =====================
|
|
if (false) {}
|
|
// ===================== Size =====================
|
|
const mergedSize = (0,useSize/* default */.Z)(ctx => {
|
|
var _a;
|
|
return (_a = customizeSize !== null && customizeSize !== void 0 ? customizeSize : compactSize) !== null && _a !== void 0 ? _a : ctx;
|
|
});
|
|
// ===================== Disabled =====================
|
|
const disabled = react.useContext(DisabledContext/* default */.Z);
|
|
const mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
// ===================== FormItemInput =====================
|
|
const formItemContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM);
|
|
const {
|
|
hasFeedback,
|
|
status: contextStatus,
|
|
feedbackIcon
|
|
} = formItemContext;
|
|
const 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, () => ({
|
|
focus: () => {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.focus();
|
|
},
|
|
blur: () => {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.blur();
|
|
}
|
|
}));
|
|
const [contextLocale] = (0,useLocale/* default */.Z)('Calendar', en_US/* default */.Z);
|
|
const locale = Object.assign(Object.assign({}, contextLocale), props.locale);
|
|
return wrapSSR( /*#__PURE__*/react.createElement(es_RangePicker, Object.assign({
|
|
separator: /*#__PURE__*/react.createElement("span", {
|
|
"aria-label": "to",
|
|
className: `${prefixCls}-separator`
|
|
}, /*#__PURE__*/react.createElement(icons_SwapRightOutlined, null)),
|
|
disabled: mergedDisabled,
|
|
ref: innerRef,
|
|
dropdownAlign: transPlacement2DropdownAlign(direction, placement),
|
|
placeholder: getRangePlaceholder(locale, picker, placeholder),
|
|
suffixIcon: suffixNode,
|
|
prevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-prev-icon`
|
|
}),
|
|
nextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-next-icon`
|
|
}),
|
|
superPrevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-super-prev-icon`
|
|
}),
|
|
superNextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-super-next-icon`
|
|
}),
|
|
transitionName: `${rootPrefixCls}-slide-up`
|
|
}, restProps, additionalOverrideProps, {
|
|
className: classnames_default()({
|
|
[`${prefixCls}-${mergedSize}`]: mergedSize,
|
|
[`${prefixCls}-borderless`]: !bordered
|
|
}, (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus), hasFeedback), hashId, compactItemClassnames, className, rootClassName),
|
|
locale: locale.lang,
|
|
prefixCls: prefixCls,
|
|
getPopupContainer: customGetPopupContainer || getPopupContainer,
|
|
generateConfig: generateConfig,
|
|
components: generatePicker_Components,
|
|
direction: direction,
|
|
dropdownClassName: classnames_default()(hashId, popupClassName || dropdownClassName, rootClassName),
|
|
allowClear: mergeAllowClear(allowClear, clearIcon, /*#__PURE__*/react.createElement(CloseCircleFilled/* default */.Z, null))
|
|
})));
|
|
});
|
|
if (false) {}
|
|
return RangePicker;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/generateSinglePicker.js
|
|
"use client";
|
|
|
|
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) {
|
|
const consumerName = displayName === 'TimePicker' ? 'timePicker' : 'datePicker';
|
|
const Picker = /*#__PURE__*/(0,react.forwardRef)((props, ref) => {
|
|
const {
|
|
prefixCls: customizePrefixCls,
|
|
getPopupContainer: customizeGetPopupContainer,
|
|
style,
|
|
className,
|
|
rootClassName,
|
|
size: customizeSize,
|
|
bordered = true,
|
|
placement,
|
|
placeholder,
|
|
popupClassName,
|
|
dropdownClassName,
|
|
disabled: customDisabled,
|
|
status: customStatus,
|
|
clearIcon,
|
|
allowClear
|
|
} = props,
|
|
restProps = generateSinglePicker_rest(props, ["prefixCls", "getPopupContainer", "style", "className", "rootClassName", "size", "bordered", "placement", "placeholder", "popupClassName", "dropdownClassName", "disabled", "status", "clearIcon", "allowClear"]);
|
|
const {
|
|
getPrefixCls,
|
|
direction,
|
|
getPopupContainer,
|
|
// Consume different styles according to different names
|
|
[consumerName]: consumerStyle
|
|
} = (0,react.useContext)(context/* ConfigContext */.E_);
|
|
const prefixCls = getPrefixCls('picker', customizePrefixCls);
|
|
const {
|
|
compactSize,
|
|
compactItemClassnames
|
|
} = (0,Compact/* useCompactItemContext */.ri)(prefixCls, direction);
|
|
const innerRef = react.useRef(null);
|
|
const {
|
|
format,
|
|
showTime
|
|
} = props;
|
|
const [wrapSSR, hashId] = date_picker_style(prefixCls);
|
|
(0,react.useImperativeHandle)(ref, () => ({
|
|
focus: () => {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.focus();
|
|
},
|
|
blur: () => {
|
|
var _a;
|
|
return (_a = innerRef.current) === null || _a === void 0 ? void 0 : _a.blur();
|
|
}
|
|
}));
|
|
const additionalProps = {
|
|
showToday: true
|
|
};
|
|
let additionalOverrideProps = {};
|
|
if (picker) {
|
|
additionalOverrideProps.picker = picker;
|
|
}
|
|
const mergedPicker = picker || props.picker;
|
|
additionalOverrideProps = Object.assign(Object.assign(Object.assign({}, additionalOverrideProps), showTime ? getTimeProps(Object.assign({
|
|
format,
|
|
picker: mergedPicker
|
|
}, showTime)) : {}), mergedPicker === 'time' ? getTimeProps(Object.assign(Object.assign({
|
|
format
|
|
}, props), {
|
|
picker: mergedPicker
|
|
})) : {});
|
|
const rootPrefixCls = getPrefixCls();
|
|
// =================== Warning =====================
|
|
if (false) {}
|
|
// ===================== Size =====================
|
|
const mergedSize = (0,useSize/* default */.Z)(ctx => {
|
|
var _a;
|
|
return (_a = customizeSize !== null && customizeSize !== void 0 ? customizeSize : compactSize) !== null && _a !== void 0 ? _a : ctx;
|
|
});
|
|
// ===================== Disabled =====================
|
|
const disabled = react.useContext(DisabledContext/* default */.Z);
|
|
const mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
|
|
// ===================== FormItemInput =====================
|
|
const formItemContext = (0,react.useContext)(form_context/* FormItemInputContext */.aM);
|
|
const {
|
|
hasFeedback,
|
|
status: contextStatus,
|
|
feedbackIcon
|
|
} = formItemContext;
|
|
const suffixNode = /*#__PURE__*/react.createElement(react.Fragment, null, mergedPicker === 'time' ? /*#__PURE__*/react.createElement(icons_ClockCircleOutlined, null) : /*#__PURE__*/react.createElement(icons_CalendarOutlined, null), hasFeedback && feedbackIcon);
|
|
const [contextLocale] = (0,useLocale/* default */.Z)('DatePicker', en_US/* default */.Z);
|
|
const locale = Object.assign(Object.assign({}, contextLocale), props.locale);
|
|
return wrapSSR( /*#__PURE__*/react.createElement(rc_picker_es, Object.assign({
|
|
ref: innerRef,
|
|
placeholder: getPlaceholder(locale, mergedPicker, placeholder),
|
|
suffixIcon: suffixNode,
|
|
dropdownAlign: transPlacement2DropdownAlign(direction, placement),
|
|
prevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-prev-icon`
|
|
}),
|
|
nextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-next-icon`
|
|
}),
|
|
superPrevIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-super-prev-icon`
|
|
}),
|
|
superNextIcon: /*#__PURE__*/react.createElement("span", {
|
|
className: `${prefixCls}-super-next-icon`
|
|
}),
|
|
transitionName: `${rootPrefixCls}-slide-up`
|
|
}, additionalProps, restProps, additionalOverrideProps, {
|
|
locale: locale.lang,
|
|
className: classnames_default()({
|
|
[`${prefixCls}-${mergedSize}`]: mergedSize,
|
|
[`${prefixCls}-borderless`]: !bordered
|
|
}, (0,statusUtils/* getStatusClassNames */.Z)(prefixCls, (0,statusUtils/* getMergedStatus */.F)(contextStatus, customStatus), hasFeedback), hashId, compactItemClassnames, consumerStyle === null || consumerStyle === void 0 ? void 0 : consumerStyle.className, className, rootClassName),
|
|
style: Object.assign(Object.assign({}, consumerStyle === null || consumerStyle === void 0 ? void 0 : consumerStyle.style), style),
|
|
prefixCls: prefixCls,
|
|
getPopupContainer: customizeGetPopupContainer || getPopupContainer,
|
|
generateConfig: generateConfig,
|
|
components: generatePicker_Components,
|
|
direction: direction,
|
|
disabled: mergedDisabled,
|
|
dropdownClassName: classnames_default()(hashId, rootClassName, popupClassName || dropdownClassName),
|
|
allowClear: mergeAllowClear(allowClear, clearIcon, /*#__PURE__*/react.createElement(CloseCircleFilled/* default */.Z, null))
|
|
})));
|
|
});
|
|
if (displayName) {
|
|
Picker.displayName = displayName;
|
|
}
|
|
return Picker;
|
|
}
|
|
const DatePicker = getPicker();
|
|
const WeekPicker = getPicker('week', 'WeekPicker');
|
|
const MonthPicker = getPicker('month', 'MonthPicker');
|
|
const YearPicker = getPicker('year', 'YearPicker');
|
|
const TimePicker = getPicker('time', 'TimePicker');
|
|
const QuarterPicker = getPicker('quarter', 'QuarterPicker');
|
|
return {
|
|
DatePicker,
|
|
WeekPicker,
|
|
MonthPicker,
|
|
YearPicker,
|
|
TimePicker,
|
|
QuarterPicker
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/index.js
|
|
"use client";
|
|
|
|
|
|
|
|
const DataPickerPlacements = (/* unused pure expression or super */ null && (['bottomLeft', 'bottomRight', 'topLeft', 'topRight']));
|
|
function generatePicker_generatePicker(generateConfig) {
|
|
// =========================== Picker ===========================
|
|
const {
|
|
DatePicker,
|
|
WeekPicker,
|
|
MonthPicker,
|
|
YearPicker,
|
|
TimePicker,
|
|
QuarterPicker
|
|
} = generatePicker(generateConfig);
|
|
// ======================== Range Picker ========================
|
|
const RangePicker = generateRangePicker(generateConfig);
|
|
const MergedDatePicker = DatePicker;
|
|
MergedDatePicker.WeekPicker = WeekPicker;
|
|
MergedDatePicker.MonthPicker = MonthPicker;
|
|
MergedDatePicker.YearPicker = YearPicker;
|
|
MergedDatePicker.RangePicker = RangePicker;
|
|
MergedDatePicker.TimePicker = TimePicker;
|
|
MergedDatePicker.QuarterPicker = QuarterPicker;
|
|
if (false) {}
|
|
return MergedDatePicker;
|
|
}
|
|
/* harmony default export */ var date_picker_generatePicker = (generatePicker_generatePicker);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/index.js
|
|
"use client";
|
|
|
|
|
|
|
|
|
|
|
|
const DatePicker = date_picker_generatePicker(dayjs);
|
|
function postPureProps(props) {
|
|
const dropdownAlign = transPlacement2DropdownAlign(props.direction, props.placement);
|
|
dropdownAlign.overflow.adjustY = false;
|
|
dropdownAlign.overflow.adjustX = false;
|
|
return Object.assign(Object.assign({}, props), {
|
|
dropdownAlign
|
|
});
|
|
}
|
|
// We don't care debug panel
|
|
/* istanbul ignore next */
|
|
const date_picker_PurePanel = (0,PurePanel/* default */.Z)(DatePicker, 'picker', null, postPureProps);
|
|
DatePicker._InternalPanelDoNotUseOrYouWillBeFired = date_picker_PurePanel;
|
|
const PureRangePanel = (0,PurePanel/* default */.Z)(DatePicker.RangePicker, 'picker', null, postPureProps);
|
|
DatePicker._InternalRangePanelDoNotUseOrYouWillBeFired = PureRangePanel;
|
|
DatePicker.generatePicker = date_picker_generatePicker;
|
|
/* harmony default export */ var date_picker = (DatePicker);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 97909:
|
|
/*!***********************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/dayjs.min.js ***!
|
|
\***********************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(t,e){ true?module.exports=e():0}(this,(function(){"use strict";var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",c="month",f="quarter",h="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return"["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return-t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,c),s=n-i<0,u=e.clone().add(r+(s?-1:1),c);return+(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return{M:c,y:h,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:f}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},g="en",D={};D[g]=M;var p=function(t){return t instanceof b},S=function t(e,n,r){var i;if(!e)return g;if("string"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split("-");if(!i&&u.length>1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},w=function(t,e){if(p(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new b(n)},O=v;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var b=function(){function M(t){this.$L=S(t.locale,null,!0),this.parse(t)}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return O},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,f=O.p(t),l=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return O.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v="set"+(this.$u?"UTC":"");switch(f){case h:return r?l(1,0):l(31,11);case c:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+"Hours",0);case u:return $(v+"Minutes",1);case s:return $(v+"Seconds",2);case i:return $(v+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=O.p(t),f="set"+(this.$u?"UTC":""),l=(n={},n[a]=f+"Date",n[d]=f+"Date",n[c]=f+"Month",n[h]=f+"FullYear",n[u]=f+"Hours",n[s]=f+"Minutes",n[i]=f+"Seconds",n[r]=f+"Milliseconds",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===c||o===h){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,f){var d,l=this;r=Number(r);var $=O.p(f),y=function(t){var e=w(l);return O.w(e.date(e.date()+Math.round(t*r)),l)};if($===c)return this.set(c,this.$M+r);if($===h)return this.set(h,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,c=n.months,f=n.meridiem,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},d=function(t){return O.s(s%12||12,t,"0")},$=f||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r};return r.replace(y,(function(t,r){return r||function(t){switch(t){case"YY":return String(e.$y).slice(-2);case"YYYY":return O.s(e.$y,4,"0");case"M":return a+1;case"MM":return O.s(a+1,2,"0");case"MMM":return h(n.monthsShort,a,c,3);case"MMMM":return h(c,a);case"D":return e.$D;case"DD":return O.s(e.$D,2,"0");case"d":return String(e.$W);case"dd":return h(n.weekdaysMin,e.$W,o,2);case"ddd":return h(n.weekdaysShort,e.$W,o,3);case"dddd":return o[e.$W];case"H":return String(s);case"HH":return O.s(s,2,"0");case"h":return d(1);case"hh":return d(2);case"a":return $(s,u,!0);case"A":return $(s,u,!1);case"m":return String(u);case"mm":return O.s(u,2,"0");case"s":return String(e.$s);case"ss":return O.s(e.$s,2,"0");case"SSS":return O.s(e.$ms,3,"0");case"Z":return i}return null}(t)||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=this,M=O.p(d),m=w(r),v=(m.utcOffset()-this.utcOffset())*e,g=this-m,D=function(){return O.m(y,m)};switch(M){case h:$=D()/12;break;case c:$=D();break;case f:$=D()/3;break;case o:$=(g-v)/6048e5;break;case a:$=(g-v)/864e5;break;case u:$=g/n;break;case s:$=g/e;break;case i:$=g/t;break;default:$=g}return l?$:O.a($)},m.daysInMonth=function(){return this.endOf(c).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),_=b.prototype;return w.prototype=_,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",c],["$y",h],["$D",d]].forEach((function(t){_[t[1]]=function(e){return this.$g(e,t[0],t[1])}})),w.extend=function(t,e){return t.$i||(t(e,b,w),t.$i=!0),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=D[g],w.Ls=D,w.p={},w}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 86625:
|
|
/*!***********************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/plugin/advancedFormat.js ***!
|
|
\***********************************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(e,t){ true?module.exports=t():0}(this,(function(){"use strict";return function(e,t){var r=t.prototype,n=r.format;r.format=function(e){var t=this,r=this.$locale();if(!this.isValid())return n.bind(this)(e);var s=this.$utils(),a=(e||"YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(e){switch(e){case"Q":return Math.ceil((t.$M+1)/3);case"Do":return r.ordinal(t.$D);case"gggg":return t.weekYear();case"GGGG":return t.isoWeekYear();case"wo":return r.ordinal(t.week(),"W");case"w":case"ww":return s.s(t.week(),"w"===e?1:2,"0");case"W":case"WW":return s.s(t.isoWeek(),"W"===e?1:2,"0");case"k":case"kk":return s.s(String(0===t.$H?24:t.$H),"k"===e?1:2,"0");case"X":return Math.floor(t.$d.getTime()/1e3);case"x":return t.$d.getTime();case"z":return"["+t.offsetName()+"]";case"zzz":return"["+t.offsetName("long")+"]";default:return e}}));return n.bind(this)(a)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 40618:
|
|
/*!**************************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/plugin/customParseFormat.js ***!
|
|
\**************************************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(e,t){ true?module.exports=t():0}(this,(function(){"use strict";var e={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},t=/(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g,n=/\d\d/,r=/\d\d?/,i=/\d*[^-_:/,()\s\d]+/,o={},s=function(e){return(e=+e)+(e>68?1900:2e3)};var a=function(e){return function(t){this[e]=+t}},f=[/[+-]\d\d:?(\d\d)?|Z/,function(e){(this.zone||(this.zone={})).offset=function(e){if(!e)return 0;if("Z"===e)return 0;var t=e.match(/([+-]|\d\d)/g),n=60*t[1]+(+t[2]||0);return 0===n?0:"+"===t[0]?-n:n}(e)}],h=function(e){var t=o[e];return t&&(t.indexOf?t:t.s.concat(t.f))},u=function(e,t){var n,r=o.meridiem;if(r){for(var i=1;i<=24;i+=1)if(e.indexOf(r(i,0,t))>-1){n=i>12;break}}else n=e===(t?"pm":"PM");return n},d={A:[i,function(e){this.afternoon=u(e,!1)}],a:[i,function(e){this.afternoon=u(e,!0)}],S:[/\d/,function(e){this.milliseconds=100*+e}],SS:[n,function(e){this.milliseconds=10*+e}],SSS:[/\d{3}/,function(e){this.milliseconds=+e}],s:[r,a("seconds")],ss:[r,a("seconds")],m:[r,a("minutes")],mm:[r,a("minutes")],H:[r,a("hours")],h:[r,a("hours")],HH:[r,a("hours")],hh:[r,a("hours")],D:[r,a("day")],DD:[n,a("day")],Do:[i,function(e){var t=o.ordinal,n=e.match(/\d+/);if(this.day=n[0],t)for(var r=1;r<=31;r+=1)t(r).replace(/\[|\]/g,"")===e&&(this.day=r)}],M:[r,a("month")],MM:[n,a("month")],MMM:[i,function(e){var t=h("months"),n=(h("monthsShort")||t.map((function(e){return e.slice(0,3)}))).indexOf(e)+1;if(n<1)throw new Error;this.month=n%12||n}],MMMM:[i,function(e){var t=h("months").indexOf(e)+1;if(t<1)throw new Error;this.month=t%12||t}],Y:[/[+-]?\d+/,a("year")],YY:[n,function(e){this.year=s(e)}],YYYY:[/\d{4}/,a("year")],Z:f,ZZ:f};function c(n){var r,i;r=n,i=o&&o.formats;for(var s=(n=r.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,n,r){var o=r&&r.toUpperCase();return n||i[r]||e[r]||i[o].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(e,t,n){return t||n.slice(1)}))}))).match(t),a=s.length,f=0;f<a;f+=1){var h=s[f],u=d[h],c=u&&u[0],l=u&&u[1];s[f]=l?{regex:c,parser:l}:h.replace(/^\[|\]$/g,"")}return function(e){for(var t={},n=0,r=0;n<a;n+=1){var i=s[n];if("string"==typeof i)r+=i.length;else{var o=i.regex,f=i.parser,h=e.slice(r),u=o.exec(h)[0];f.call(t,u),e=e.replace(u,"")}}return function(e){var t=e.afternoon;if(void 0!==t){var n=e.hours;t?n<12&&(e.hours+=12):12===n&&(e.hours=0),delete e.afternoon}}(t),t}}return function(e,t,n){n.p.customParseFormat=!0,e&&e.parseTwoDigitYear&&(s=e.parseTwoDigitYear);var r=t.prototype,i=r.parse;r.parse=function(e){var t=e.date,r=e.utc,s=e.args;this.$u=r;var a=s[1];if("string"==typeof a){var f=!0===s[2],h=!0===s[3],u=f||h,d=s[2];h&&(d=s[2]),o=this.$locale(),!f&&d&&(o=n.Ls[d]),this.$d=function(e,t,n){try{if(["x","X"].indexOf(t)>-1)return new Date(("X"===t?1e3:1)*e);var r=c(t)(e),i=r.year,o=r.month,s=r.day,a=r.hours,f=r.minutes,h=r.seconds,u=r.milliseconds,d=r.zone,l=new Date,m=s||(i||o?1:l.getDate()),M=i||l.getFullYear(),Y=0;i&&!o||(Y=o>0?o-1:l.getMonth());var p=a||0,v=f||0,D=h||0,g=u||0;return d?new Date(Date.UTC(M,Y,m,p,v,D,g+60*d.offset*1e3)):n?new Date(Date.UTC(M,Y,m,p,v,D,g)):new Date(M,Y,m,p,v,D,g)}catch(e){return new Date("")}}(t,a,r),this.init(),d&&!0!==d&&(this.$L=this.locale(d).$L),u&&t!=this.format(a)&&(this.$d=new Date("")),o={}}else if(a instanceof Array)for(var l=a.length,m=1;m<=l;m+=1){s[1]=a[m-1];var M=n.apply(this,s);if(M.isValid()){this.$d=M.$d,this.$L=M.$L,this.init();break}m===l&&(this.$d=new Date(""))}else i.call(this,e)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 26850:
|
|
/*!*******************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/plugin/localeData.js ***!
|
|
\*******************************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(n,e){ true?module.exports=e():0}(this,(function(){"use strict";return function(n,e,t){var r=e.prototype,o=function(n){return n&&(n.indexOf?n:n.s)},u=function(n,e,t,r,u){var i=n.name?n:n.$locale(),a=o(i[e]),s=o(i[t]),f=a||s.map((function(n){return n.slice(0,r)}));if(!u)return f;var d=i.weekStart;return f.map((function(n,e){return f[(e+(d||0))%7]}))},i=function(){return t.Ls[t.locale()]},a=function(n,e){return n.formats[e]||function(n){return n.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(n,e,t){return e||t.slice(1)}))}(n.formats[e.toUpperCase()])},s=function(){var n=this;return{months:function(e){return e?e.format("MMMM"):u(n,"months")},monthsShort:function(e){return e?e.format("MMM"):u(n,"monthsShort","months",3)},firstDayOfWeek:function(){return n.$locale().weekStart||0},weekdays:function(e){return e?e.format("dddd"):u(n,"weekdays")},weekdaysMin:function(e){return e?e.format("dd"):u(n,"weekdaysMin","weekdays",2)},weekdaysShort:function(e){return e?e.format("ddd"):u(n,"weekdaysShort","weekdays",3)},longDateFormat:function(e){return a(n.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},t.localeData=function(){var n=i();return{firstDayOfWeek:function(){return n.weekStart||0},weekdays:function(){return t.weekdays()},weekdaysShort:function(){return t.weekdaysShort()},weekdaysMin:function(){return t.weekdaysMin()},months:function(){return t.months()},monthsShort:function(){return t.monthsShort()},longDateFormat:function(e){return a(n,e)},meridiem:n.meridiem,ordinal:n.ordinal}},t.months=function(){return u(i(),"months")},t.monthsShort=function(){return u(i(),"monthsShort","months",3)},t.weekdays=function(n){return u(i(),"weekdays",null,null,n)},t.weekdaysShort=function(n){return u(i(),"weekdaysShort","weekdays",3,n)},t.weekdaysMin=function(n){return u(i(),"weekdaysMin","weekdays",2,n)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 90888:
|
|
/*!*******************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/plugin/weekOfYear.js ***!
|
|
\*******************************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(e,t){ true?module.exports=t():0}(this,(function(){"use strict";var e="week",t="year";return function(i,n,r){var f=n.prototype;f.week=function(i){if(void 0===i&&(i=null),null!==i)return this.add(7*(i-this.week()),"day");var n=this.$locale().yearStart||1;if(11===this.month()&&this.date()>25){var f=r(this).startOf(t).add(1,t).date(n),s=r(this).endOf(e);if(f.isBefore(s))return 1}var a=r(this).startOf(t).date(n).startOf(e).subtract(1,"millisecond"),o=this.diff(a,e,!0);return o<0?r(this).startOf("week").week():Math.ceil(o)},f.weeks=function(e){return void 0===e&&(e=null),this.week(e)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 99873:
|
|
/*!*****************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/plugin/weekYear.js ***!
|
|
\*****************************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(e,t){ true?module.exports=t():0}(this,(function(){"use strict";return function(e,t){t.prototype.weekYear=function(){var e=this.month(),t=this.week(),n=this.year();return 1===t&&11===e?n+1:0===e&&t>=52?n-1:n}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 33088:
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/dayjs/plugin/weekday.js ***!
|
|
\****************************************************************/
|
|
/***/ (function(module) {
|
|
|
|
!function(e,t){ true?module.exports=t():0}(this,(function(){"use strict";return function(e,t){t.prototype.weekday=function(e){var t=this.$locale().weekStart||0,i=this.$W,n=(i<t?i+7:i)-t;return this.$utils().u(e)?n:this.subtract(n,"day").add(e,"day")}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 15633:
|
|
/*!*******************************************************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/rc-picker/node_modules/react-is/cjs/react-is.production.min.js ***!
|
|
\*******************************************************************************************************/
|
|
/***/ (function(__unused_webpack_module, exports) {
|
|
|
|
"use strict";
|
|
var __webpack_unused_export__;
|
|
/** @license React v16.13.1
|
|
* react-is.production.min.js
|
|
*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
|
|
Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
|
|
function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}__webpack_unused_export__=l;__webpack_unused_export__=m;__webpack_unused_export__=k;__webpack_unused_export__=h;__webpack_unused_export__=c;__webpack_unused_export__=n;__webpack_unused_export__=e;__webpack_unused_export__=t;__webpack_unused_export__=r;__webpack_unused_export__=d;
|
|
__webpack_unused_export__=g;__webpack_unused_export__=f;__webpack_unused_export__=p;__webpack_unused_export__=function(a){return A(a)||z(a)===l};__webpack_unused_export__=A;__webpack_unused_export__=function(a){return z(a)===k};__webpack_unused_export__=function(a){return z(a)===h};__webpack_unused_export__=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};__webpack_unused_export__=function(a){return z(a)===n};__webpack_unused_export__=function(a){return z(a)===e};__webpack_unused_export__=function(a){return z(a)===t};
|
|
exports.isMemo=function(a){return z(a)===r};__webpack_unused_export__=function(a){return z(a)===d};__webpack_unused_export__=function(a){return z(a)===g};__webpack_unused_export__=function(a){return z(a)===f};__webpack_unused_export__=function(a){return z(a)===p};
|
|
__webpack_unused_export__=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};__webpack_unused_export__=z;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 49286:
|
|
/*!*********************************************************************************!*\
|
|
!*** ./node_modules/antd/node_modules/rc-picker/node_modules/react-is/index.js ***!
|
|
\*********************************************************************************/
|
|
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
if (true) {
|
|
module.exports = __webpack_require__(/*! ./cjs/react-is.production.min.js */ 15633);
|
|
} else {}
|
|
|
|
|
|
/***/ })
|
|
|
|
}]); |