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.
8093 lines
282 KiB
8093 lines
282 KiB
(self["webpackChunk"] = self["webpackChunk"] || []).push([[71628],{
|
|
|
|
/***/ 71628:
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/antd/es/date-picker/index.js + 79 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/dayjs/dayjs.min.js
|
|
var dayjs_min = __webpack_require__(27484);
|
|
var dayjs_min_default = /*#__PURE__*/__webpack_require__.n(dayjs_min);
|
|
;// CONCATENATED MODULE: ./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/dayjs/plugin/weekday.js
|
|
var weekday = __webpack_require__(6833);
|
|
var weekday_default = /*#__PURE__*/__webpack_require__.n(weekday);
|
|
// EXTERNAL MODULE: ./node_modules/dayjs/plugin/localeData.js
|
|
var localeData = __webpack_require__(96036);
|
|
var localeData_default = /*#__PURE__*/__webpack_require__.n(localeData);
|
|
// EXTERNAL MODULE: ./node_modules/dayjs/plugin/weekOfYear.js
|
|
var weekOfYear = __webpack_require__(55183);
|
|
var weekOfYear_default = /*#__PURE__*/__webpack_require__.n(weekOfYear);
|
|
// EXTERNAL MODULE: ./node_modules/dayjs/plugin/weekYear.js
|
|
var weekYear = __webpack_require__(172);
|
|
var weekYear_default = /*#__PURE__*/__webpack_require__.n(weekYear);
|
|
// EXTERNAL MODULE: ./node_modules/dayjs/plugin/advancedFormat.js
|
|
var advancedFormat = __webpack_require__(28734);
|
|
var advancedFormat_default = /*#__PURE__*/__webpack_require__.n(advancedFormat);
|
|
// EXTERNAL MODULE: ./node_modules/dayjs/plugin/customParseFormat.js
|
|
var customParseFormat = __webpack_require__(10285);
|
|
var customParseFormat_default = /*#__PURE__*/__webpack_require__.n(customParseFormat);
|
|
;// CONCATENATED MODULE: ./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);
|
|
;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/CalendarOutlined.js
|
|
// This icon file is generated automatically.
|
|
var CalendarOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "64 64 896 896", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M880 184H712v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H384v-64c0-4.4-3.6-8-8-8h-56c-4.4 0-8 3.6-8 8v64H144c-17.7 0-32 14.3-32 32v664c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V216c0-17.7-14.3-32-32-32zm-40 656H184V460h656v380zM184 392V256h128v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h256v48c0 4.4 3.6 8 8 8h56c4.4 0 8-3.6 8-8v-48h128v136H184z" } }] }, "name": "calendar", "theme": "outlined" };
|
|
/* harmony default export */ var asn_CalendarOutlined = (CalendarOutlined);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@ant-design/icons/es/components/AntdIcon.js + 8 modules
|
|
var AntdIcon = __webpack_require__(74643);
|
|
;// CONCATENATED MODULE: ./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/@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/@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/@ant-design/icons/es/icons/CloseCircleFilled.js + 1 modules
|
|
var CloseCircleFilled = __webpack_require__(4340);
|
|
;// CONCATENATED MODULE: ./node_modules/@ant-design/icons-svg/es/asn/SwapRightOutlined.js
|
|
// This icon file is generated automatically.
|
|
var SwapRightOutlined = { "icon": { "tag": "svg", "attrs": { "viewBox": "0 0 1024 1024", "focusable": "false" }, "children": [{ "tag": "path", "attrs": { "d": "M873.1 596.2l-164-208A32 32 0 00684 376h-64.8c-6.7 0-10.4 7.7-6.3 13l144.3 183H152c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h695.9c26.8 0 41.7-30.8 25.2-51.8z" } }] }, "name": "swap-right", "theme": "outlined" };
|
|
/* harmony default export */ var asn_SwapRightOutlined = (SwapRightOutlined);
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@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/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/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/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/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/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/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/rc-picker/node_modules/rc-util/es/hooks/useMemo.js
|
|
|
|
function 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/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/rc-picker/es/panels/DecadePanel/constant.js
|
|
var DECADE_UNIT_DIFF = 10;
|
|
var DECADE_DISTANCE_COUNT = DECADE_UNIT_DIFF * 10;
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/dateUtil.js
|
|
|
|
var WEEK_DAY_COUNT = 7;
|
|
function isNullEqual(value1, value2) {
|
|
if (!value1 && !value2) {
|
|
return true;
|
|
}
|
|
if (!value1 || !value2) {
|
|
return false;
|
|
}
|
|
return undefined;
|
|
}
|
|
function isSameDecade(generateConfig, decade1, decade2) {
|
|
var equal = isNullEqual(decade1, decade2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
var num1 = Math.floor(generateConfig.getYear(decade1) / 10);
|
|
var num2 = Math.floor(generateConfig.getYear(decade2) / 10);
|
|
return num1 === num2;
|
|
}
|
|
function isSameYear(generateConfig, year1, year2) {
|
|
var equal = isNullEqual(year1, year2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.getYear(year1) === generateConfig.getYear(year2);
|
|
}
|
|
function getQuarter(generateConfig, date) {
|
|
var quota = Math.floor(generateConfig.getMonth(date) / 3);
|
|
return quota + 1;
|
|
}
|
|
function isSameQuarter(generateConfig, quarter1, quarter2) {
|
|
var equal = isNullEqual(quarter1, quarter2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return isSameYear(generateConfig, quarter1, quarter2) && getQuarter(generateConfig, quarter1) === getQuarter(generateConfig, quarter2);
|
|
}
|
|
function isSameMonth(generateConfig, month1, month2) {
|
|
var equal = isNullEqual(month1, month2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return isSameYear(generateConfig, month1, month2) && generateConfig.getMonth(month1) === generateConfig.getMonth(month2);
|
|
}
|
|
function isSameDate(generateConfig, date1, date2) {
|
|
var equal = isNullEqual(date1, date2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.getYear(date1) === generateConfig.getYear(date2) && generateConfig.getMonth(date1) === generateConfig.getMonth(date2) && generateConfig.getDate(date1) === generateConfig.getDate(date2);
|
|
}
|
|
function isSameTime(generateConfig, time1, time2) {
|
|
var equal = isNullEqual(time1, time2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.getHour(time1) === generateConfig.getHour(time2) && generateConfig.getMinute(time1) === generateConfig.getMinute(time2) && generateConfig.getSecond(time1) === generateConfig.getSecond(time2);
|
|
}
|
|
function isSameWeek(generateConfig, locale, date1, date2) {
|
|
var equal = isNullEqual(date1, date2);
|
|
if (typeof equal === 'boolean') {
|
|
return equal;
|
|
}
|
|
return generateConfig.locale.getWeek(locale, date1) === generateConfig.locale.getWeek(locale, date2);
|
|
}
|
|
function 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/rc-picker/es/hooks/useValueTexts.js
|
|
|
|
|
|
|
|
function useValueTexts(value, _ref) {
|
|
var formatList = _ref.formatList,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale;
|
|
return 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], function (prev, next) {
|
|
return (
|
|
// Not Same Date
|
|
!dateUtil_isEqual(generateConfig, prev[0], next[0]) ||
|
|
// Not Same format
|
|
!es_isEqual(prev[1], next[1], true)
|
|
);
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useHoverValue.js
|
|
|
|
|
|
|
|
function useHoverValue(valueText, _ref) {
|
|
var formatList = _ref.formatList,
|
|
generateConfig = _ref.generateConfig,
|
|
locale = _ref.locale;
|
|
var _useState = (0,react.useState)(null),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
value = _useState2[0],
|
|
internalSetValue = _useState2[1];
|
|
var raf = (0,react.useRef)(null);
|
|
function setValue(val) {
|
|
var immediately = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
cancelAnimationFrame(raf.current);
|
|
if (immediately) {
|
|
internalSetValue(val);
|
|
return;
|
|
}
|
|
raf.current = requestAnimationFrame(function () {
|
|
internalSetValue(val);
|
|
});
|
|
}
|
|
var _useValueTexts = useValueTexts(value, {
|
|
formatList: formatList,
|
|
generateConfig: generateConfig,
|
|
locale: locale
|
|
}),
|
|
_useValueTexts2 = (0,slicedToArray/* default */.Z)(_useValueTexts, 2),
|
|
firstText = _useValueTexts2[1];
|
|
function onEnter(date) {
|
|
setValue(date);
|
|
}
|
|
function onLeave() {
|
|
var immediately = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
setValue(null, immediately);
|
|
}
|
|
(0,react.useEffect)(function () {
|
|
onLeave(true);
|
|
}, [valueText]);
|
|
(0,react.useEffect)(function () {
|
|
return function () {
|
|
return cancelAnimationFrame(raf.current);
|
|
};
|
|
}, []);
|
|
return [firstText, onEnter, onLeave];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/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/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/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/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/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/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.');
|
|
var rangeLabels = Object.keys(legacyRanges);
|
|
return rangeLabels.map(function (label) {
|
|
var range = legacyRanges[label];
|
|
var newValues = typeof range === 'function' ? range() : range;
|
|
return {
|
|
label: label,
|
|
value: newValues
|
|
};
|
|
});
|
|
}
|
|
return [];
|
|
}, [presets, legacyRanges]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useTextValueMapping.js
|
|
|
|
|
|
|
|
function useTextValueMapping(_ref) {
|
|
var valueTexts = _ref.valueTexts,
|
|
onTextChange = _ref.onTextChange;
|
|
var _React$useState = react.useState(''),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
text = _React$useState2[0],
|
|
setInnerText = _React$useState2[1];
|
|
var valueTextsRef = react.useRef([]);
|
|
valueTextsRef.current = valueTexts;
|
|
function triggerTextChange(value) {
|
|
setInnerText(value);
|
|
onTextChange(value);
|
|
}
|
|
function resetText() {
|
|
setInnerText(valueTextsRef.current[0]);
|
|
}
|
|
hooks_useLayoutEffect(function () {
|
|
if (valueTexts.every(function (valText) {
|
|
return valText !== text;
|
|
})) {
|
|
resetText();
|
|
}
|
|
}, [valueTexts.join('||')]);
|
|
return [text, triggerTextChange, resetText];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/PanelContext.js
|
|
|
|
var PanelContext = /*#__PURE__*/react.createContext({});
|
|
/* harmony default export */ var es_PanelContext = (PanelContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/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/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;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useCellClassName.js
|
|
|
|
|
|
|
|
function useCellClassName(_ref) {
|
|
var cellPrefixCls = _ref.cellPrefixCls,
|
|
generateConfig = _ref.generateConfig,
|
|
rangedValue = _ref.rangedValue,
|
|
hoverRangedValue = _ref.hoverRangedValue,
|
|
isInView = _ref.isInView,
|
|
isSameCell = _ref.isSameCell,
|
|
offsetCell = _ref.offsetCell,
|
|
today = _ref.today,
|
|
value = _ref.value;
|
|
function getClassName(currentDate) {
|
|
var _ref2;
|
|
var prevDate = offsetCell(currentDate, -1);
|
|
var nextDate = offsetCell(currentDate, 1);
|
|
var rangeStart = getValue(rangedValue, 0);
|
|
var rangeEnd = getValue(rangedValue, 1);
|
|
var hoverStart = getValue(hoverRangedValue, 0);
|
|
var hoverEnd = getValue(hoverRangedValue, 1);
|
|
var isRangeHovered = isInRange(generateConfig, hoverStart, hoverEnd, currentDate);
|
|
function isRangeStart(date) {
|
|
return isSameCell(rangeStart, date);
|
|
}
|
|
function isRangeEnd(date) {
|
|
return isSameCell(rangeEnd, date);
|
|
}
|
|
var isHoverStart = isSameCell(hoverStart, currentDate);
|
|
var isHoverEnd = isSameCell(hoverEnd, currentDate);
|
|
var isHoverEdgeStart = (isRangeHovered || isHoverEnd) && (!isInView(prevDate) || isRangeEnd(prevDate));
|
|
var isHoverEdgeEnd = (isRangeHovered || isHoverStart) && (!isInView(nextDate) || isRangeStart(nextDate));
|
|
return _ref2 = {}, (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-in-view"), isInView(currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-in-range"), isInRange(generateConfig, rangeStart, rangeEnd, currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-start"), isRangeStart(currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-end"), isRangeEnd(currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-start-single"), isRangeStart(currentDate) && !rangeEnd), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-end-single"), isRangeEnd(currentDate) && !rangeStart), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-start-near-hover"), isRangeStart(currentDate) && (isSameCell(prevDate, hoverStart) || isInRange(generateConfig, hoverStart, hoverEnd, prevDate))), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-end-near-hover"), isRangeEnd(currentDate) && (isSameCell(nextDate, hoverEnd) || isInRange(generateConfig, hoverStart, hoverEnd, nextDate))), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover"), isRangeHovered), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-start"), isHoverStart), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-end"), isHoverEnd), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-start"), isHoverEdgeStart), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-end"), isHoverEdgeEnd), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-start-near-range"), isHoverEdgeStart && isSameCell(prevDate, rangeEnd)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-end-near-range"), isHoverEdgeEnd && isSameCell(nextDate, rangeStart)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-today"), isSameCell(today, currentDate)), (0,defineProperty/* default */.Z)(_ref2, "".concat(cellPrefixCls, "-selected"), isSameCell(value, currentDate)), _ref2;
|
|
}
|
|
return getClassName;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/RangeContext.js
|
|
|
|
var RangeContext = /*#__PURE__*/react.createContext({});
|
|
/* harmony default export */ var es_RangeContext = (RangeContext);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/timeUtil.js
|
|
function timeUtil_setTime(generateConfig, date, hour, minute, second) {
|
|
var nextTime = generateConfig.setHour(date, hour);
|
|
nextTime = generateConfig.setMinute(nextTime, minute);
|
|
nextTime = generateConfig.setSecond(nextTime, second);
|
|
return nextTime;
|
|
}
|
|
function setDateTime(generateConfig, date, defaultDate) {
|
|
if (!defaultDate) {
|
|
return date;
|
|
}
|
|
var newDate = date;
|
|
newDate = generateConfig.setHour(newDate, generateConfig.getHour(defaultDate));
|
|
newDate = generateConfig.setMinute(newDate, generateConfig.getMinute(defaultDate));
|
|
newDate = generateConfig.setSecond(newDate, generateConfig.getSecond(defaultDate));
|
|
return newDate;
|
|
}
|
|
function getLowerBoundTime(hour, minute, second, hourStep, minuteStep, secondStep) {
|
|
var lowerBoundHour = Math.floor(hour / hourStep) * hourStep;
|
|
if (lowerBoundHour < hour) {
|
|
return [lowerBoundHour, 60 - minuteStep, 60 - secondStep];
|
|
}
|
|
var lowerBoundMinute = Math.floor(minute / minuteStep) * minuteStep;
|
|
if (lowerBoundMinute < minute) {
|
|
return [lowerBoundHour, lowerBoundMinute, 60 - secondStep];
|
|
}
|
|
var lowerBoundSecond = Math.floor(second / secondStep) * secondStep;
|
|
return [lowerBoundHour, lowerBoundMinute, lowerBoundSecond];
|
|
}
|
|
function getLastDay(generateConfig, date) {
|
|
var year = generateConfig.getYear(date);
|
|
var month = generateConfig.getMonth(date) + 1;
|
|
var endDate = generateConfig.getEndDate(generateConfig.getFixedDate("".concat(year, "-").concat(month, "-01")));
|
|
var lastDay = generateConfig.getDate(endDate);
|
|
var monthShow = month < 10 ? "0".concat(month) : "".concat(month);
|
|
return "".concat(year, "-").concat(monthShow, "-").concat(lastDay);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/PanelBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function PanelBody(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
disabledDate = _ref.disabledDate,
|
|
onSelect = _ref.onSelect,
|
|
picker = _ref.picker,
|
|
rowNum = _ref.rowNum,
|
|
colNum = _ref.colNum,
|
|
prefixColumn = _ref.prefixColumn,
|
|
rowClassName = _ref.rowClassName,
|
|
baseDate = _ref.baseDate,
|
|
getCellClassName = _ref.getCellClassName,
|
|
getCellText = _ref.getCellText,
|
|
getCellNode = _ref.getCellNode,
|
|
getCellDate = _ref.getCellDate,
|
|
generateConfig = _ref.generateConfig,
|
|
titleCell = _ref.titleCell,
|
|
headerCells = _ref.headerCells;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
onDateMouseEnter = _React$useContext.onDateMouseEnter,
|
|
onDateMouseLeave = _React$useContext.onDateMouseLeave,
|
|
mode = _React$useContext.mode;
|
|
var cellPrefixCls = "".concat(prefixCls, "-cell");
|
|
|
|
// =============================== Body ===============================
|
|
var rows = [];
|
|
for (var i = 0; i < rowNum; i += 1) {
|
|
var row = [];
|
|
var rowStartDate = void 0;
|
|
var _loop = function _loop() {
|
|
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/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/rc-picker/es/panels/Header.js
|
|
|
|
|
|
var HIDDEN_STYLE = {
|
|
visibility: 'hidden'
|
|
};
|
|
function Header(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
_ref$prevIcon = _ref.prevIcon,
|
|
prevIcon = _ref$prevIcon === void 0 ? "\u2039" : _ref$prevIcon,
|
|
_ref$nextIcon = _ref.nextIcon,
|
|
nextIcon = _ref$nextIcon === void 0 ? "\u203A" : _ref$nextIcon,
|
|
_ref$superPrevIcon = _ref.superPrevIcon,
|
|
superPrevIcon = _ref$superPrevIcon === void 0 ? "\xAB" : _ref$superPrevIcon,
|
|
_ref$superNextIcon = _ref.superNextIcon,
|
|
superNextIcon = _ref$superNextIcon === void 0 ? "\xBB" : _ref$superNextIcon,
|
|
onSuperPrev = _ref.onSuperPrev,
|
|
onSuperNext = _ref.onSuperNext,
|
|
onPrev = _ref.onPrev,
|
|
onNext = _ref.onNext,
|
|
children = _ref.children;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideNextBtn = _React$useContext.hideNextBtn,
|
|
hidePrevBtn = _React$useContext.hidePrevBtn;
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: prefixCls
|
|
}, onSuperPrev && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onSuperPrev,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-super-prev-btn"),
|
|
style: hidePrevBtn ? HIDDEN_STYLE : {}
|
|
}, superPrevIcon), onPrev && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onPrev,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-prev-btn"),
|
|
style: hidePrevBtn ? HIDDEN_STYLE : {}
|
|
}, prevIcon), /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-view")
|
|
}, children), onNext && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onNext,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-next-btn"),
|
|
style: hideNextBtn ? HIDDEN_STYLE : {}
|
|
}, nextIcon), onSuperNext && /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onSuperNext,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-super-next-btn"),
|
|
style: hideNextBtn ? HIDDEN_STYLE : {}
|
|
}, superNextIcon));
|
|
}
|
|
/* harmony default export */ var panels_Header = (Header);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DatePanel/DateHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function DateHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
viewDate = props.viewDate,
|
|
onNextMonth = props.onNextMonth,
|
|
onPrevMonth = props.onPrevMonth,
|
|
onNextYear = props.onNextYear,
|
|
onPrevYear = props.onPrevYear,
|
|
onYearClick = props.onYearClick,
|
|
onMonthClick = props.onMonthClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
var monthsLocale = locale.shortMonths || (generateConfig.locale.getShortMonths ? generateConfig.locale.getShortMonths(locale.locale) : []);
|
|
var month = generateConfig.getMonth(viewDate);
|
|
|
|
// =================== Month & Year ===================
|
|
var yearNode = /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
key: "year",
|
|
onClick: onYearClick,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-year-btn")
|
|
}, formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.yearFormat,
|
|
generateConfig: generateConfig
|
|
}));
|
|
var monthNode = /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
key: "month",
|
|
onClick: onMonthClick,
|
|
tabIndex: -1,
|
|
className: "".concat(prefixCls, "-month-btn")
|
|
}, locale.monthFormat ? formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.monthFormat,
|
|
generateConfig: generateConfig
|
|
}) : monthsLocale[month]);
|
|
var monthYearNodes = locale.monthBeforeYear ? [monthNode, yearNode] : [yearNode, monthNode];
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevYear,
|
|
onPrev: onPrevMonth,
|
|
onNext: onNextMonth,
|
|
onSuperNext: onNextYear
|
|
}), monthYearNodes);
|
|
}
|
|
/* harmony default export */ var DatePanel_DateHeader = (DateHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/DatePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var DATE_ROW_COUNT = 6;
|
|
function DatePanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
_props$panelName = props.panelName,
|
|
panelName = _props$panelName === void 0 ? 'date' : _props$panelName,
|
|
keyboardConfig = props.keyboardConfig,
|
|
active = props.active,
|
|
operationRef = props.operationRef,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
onViewDateChange = props.onViewDateChange,
|
|
onPanelChange = props.onPanelChange,
|
|
_onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-").concat(panelName, "-panel");
|
|
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, (0,objectSpread2/* default */.Z)({
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addDate(value || viewDate, diff), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addDate(value || viewDate, diff * WEEK_DAY_COUNT), 'key');
|
|
},
|
|
onPageUpDown: function onPageUpDown(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff), 'key');
|
|
}
|
|
}, keyboardConfig));
|
|
}
|
|
};
|
|
|
|
// ==================== View Operation ====================
|
|
var onYearChange = function onYearChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
var onMonthChange = function onMonthChange(diff) {
|
|
var newDate = generateConfig.addMonth(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(panelPrefixCls, (0,defineProperty/* default */.Z)({}, "".concat(panelPrefixCls, "-active"), active))
|
|
}, /*#__PURE__*/react.createElement(DatePanel_DateHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
value: value,
|
|
viewDate: viewDate
|
|
// View Operation
|
|
,
|
|
onPrevYear: function onPrevYear() {
|
|
onYearChange(-1);
|
|
},
|
|
onNextYear: function onNextYear() {
|
|
onYearChange(1);
|
|
},
|
|
onPrevMonth: function onPrevMonth() {
|
|
onMonthChange(-1);
|
|
},
|
|
onNextMonth: function onNextMonth() {
|
|
onMonthChange(1);
|
|
},
|
|
onMonthClick: function onMonthClick() {
|
|
onPanelChange('month', viewDate);
|
|
},
|
|
onYearClick: function onYearClick() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(DatePanel_DateBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
onSelect: function onSelect(date) {
|
|
return _onSelect(date, 'mouse');
|
|
},
|
|
prefixCls: prefixCls,
|
|
value: value,
|
|
viewDate: viewDate,
|
|
rowCount: DATE_ROW_COUNT
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_DatePanel = (DatePanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/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/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 newDate = value || generateConfig.getNow();
|
|
var mergedHour = Math.max(0, newHour);
|
|
var mergedMinute = Math.max(0, newMinute);
|
|
var mergedSecond = Math.max(0, 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/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/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(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/rc-picker/es/panels/TimePanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var countBoolean = function countBoolean(boolList) {
|
|
return boolList.filter(function (bool) {
|
|
return bool !== false;
|
|
}).length;
|
|
};
|
|
function TimePanel(props) {
|
|
var generateConfig = props.generateConfig,
|
|
_props$format = props.format,
|
|
format = _props$format === void 0 ? 'HH:mm:ss' : _props$format,
|
|
prefixCls = props.prefixCls,
|
|
active = props.active,
|
|
operationRef = props.operationRef,
|
|
showHour = props.showHour,
|
|
showMinute = props.showMinute,
|
|
showSecond = props.showSecond,
|
|
_props$use12Hours = props.use12Hours,
|
|
use12Hours = _props$use12Hours === void 0 ? false : _props$use12Hours,
|
|
onSelect = props.onSelect,
|
|
value = props.value;
|
|
var panelPrefixCls = "".concat(prefixCls, "-time-panel");
|
|
var bodyOperationRef = react.useRef();
|
|
|
|
// ======================= Keyboard =======================
|
|
var _React$useState = react.useState(-1),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
activeColumnIndex = _React$useState2[0],
|
|
setActiveColumnIndex = _React$useState2[1];
|
|
var columnsCount = countBoolean([showHour, showMinute, showSecond, use12Hours]);
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
setActiveColumnIndex((activeColumnIndex + diff + columnsCount) % columnsCount);
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
if (activeColumnIndex === -1) {
|
|
setActiveColumnIndex(0);
|
|
} else if (bodyOperationRef.current) {
|
|
bodyOperationRef.current.onUpDown(diff);
|
|
}
|
|
},
|
|
onEnter: function onEnter() {
|
|
onSelect(value || generateConfig.getNow(), 'key');
|
|
setActiveColumnIndex(-1);
|
|
}
|
|
});
|
|
},
|
|
onBlur: function onBlur() {
|
|
setActiveColumnIndex(-1);
|
|
}
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: classnames_default()(panelPrefixCls, (0,defineProperty/* default */.Z)({}, "".concat(panelPrefixCls, "-active"), active))
|
|
}, /*#__PURE__*/react.createElement(TimePanel_TimeHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
format: format,
|
|
prefixCls: prefixCls
|
|
})), /*#__PURE__*/react.createElement(TimePanel_TimeBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
activeColumnIndex: activeColumnIndex,
|
|
operationRef: bodyOperationRef
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_TimePanel = (TimePanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/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/rc-picker/es/panels/DecadePanel/DecadeHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function DecadeHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
viewDate = props.viewDate,
|
|
onPrevDecades = props.onPrevDecades,
|
|
onNextDecades = props.onNextDecades;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
var yearNumber = generateConfig.getYear(viewDate);
|
|
var startYear = Math.floor(yearNumber / DECADE_DISTANCE_COUNT) * DECADE_DISTANCE_COUNT;
|
|
var endYear = startYear + DECADE_DISTANCE_COUNT - 1;
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevDecades,
|
|
onSuperNext: onNextDecades
|
|
}), startYear, "-", endYear);
|
|
}
|
|
/* harmony default export */ var DecadePanel_DecadeHeader = (DecadeHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/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/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/rc-picker/es/panels/MonthPanel/MonthHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function MonthHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
viewDate = props.viewDate,
|
|
onNextYear = props.onNextYear,
|
|
onPrevYear = props.onPrevYear,
|
|
onYearClick = props.onYearClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevYear,
|
|
onSuperNext: onNextYear
|
|
}), /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onYearClick,
|
|
className: "".concat(prefixCls, "-year-btn")
|
|
}, formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.yearFormat,
|
|
generateConfig: generateConfig
|
|
})));
|
|
}
|
|
/* harmony default export */ var MonthPanel_MonthHeader = (MonthHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/MonthPanel/MonthBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var MONTH_COL_COUNT = 3;
|
|
var MONTH_ROW_COUNT = 4;
|
|
function MonthBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
locale = props.locale,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
generateConfig = props.generateConfig,
|
|
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/rc-picker/es/panels/MonthPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
function MonthPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
onViewDateChange = props.onViewDateChange,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
onPanelChange = props.onPanelChange,
|
|
_onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-month-panel");
|
|
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff * MONTH_COL_COUNT), 'key');
|
|
},
|
|
onEnter: function onEnter() {
|
|
onPanelChange('date', value || viewDate);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// ==================== View Operation ====================
|
|
var onYearChange = function onYearChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: panelPrefixCls
|
|
}, /*#__PURE__*/react.createElement(MonthPanel_MonthHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onPrevYear: function onPrevYear() {
|
|
onYearChange(-1);
|
|
},
|
|
onNextYear: function onNextYear() {
|
|
onYearChange(1);
|
|
},
|
|
onYearClick: function onYearClick() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(MonthPanel_MonthBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onSelect: function onSelect(date) {
|
|
_onSelect(date, 'mouse');
|
|
onPanelChange('date', date);
|
|
}
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_MonthPanel = (MonthPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/QuarterPanel/QuarterHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function QuarterHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
locale = props.locale,
|
|
viewDate = props.viewDate,
|
|
onNextYear = props.onNextYear,
|
|
onPrevYear = props.onPrevYear,
|
|
onYearClick = props.onYearClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevYear,
|
|
onSuperNext: onNextYear
|
|
}), /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onYearClick,
|
|
className: "".concat(prefixCls, "-year-btn")
|
|
}, formatValue(viewDate, {
|
|
locale: locale,
|
|
format: locale.yearFormat,
|
|
generateConfig: generateConfig
|
|
})));
|
|
}
|
|
/* harmony default export */ var QuarterPanel_QuarterHeader = (QuarterHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/QuarterPanel/QuarterBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var QUARTER_COL_COUNT = 4;
|
|
var QUARTER_ROW_COUNT = 1;
|
|
function QuarterBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
locale = props.locale,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
generateConfig = props.generateConfig,
|
|
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/rc-picker/es/panels/QuarterPanel/index.js
|
|
|
|
|
|
|
|
|
|
|
|
function QuarterPanel(props) {
|
|
var prefixCls = props.prefixCls,
|
|
operationRef = props.operationRef,
|
|
onViewDateChange = props.onViewDateChange,
|
|
generateConfig = props.generateConfig,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
onPanelChange = props.onPanelChange,
|
|
_onSelect = props.onSelect;
|
|
var panelPrefixCls = "".concat(prefixCls, "-quarter-panel");
|
|
|
|
// ======================= Keyboard =======================
|
|
operationRef.current = {
|
|
onKeyDown: function onKeyDown(event) {
|
|
return createKeyDownHandler(event, {
|
|
onLeftRight: function onLeftRight(diff) {
|
|
_onSelect(generateConfig.addMonth(value || viewDate, diff * 3), 'key');
|
|
},
|
|
onCtrlLeftRight: function onCtrlLeftRight(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
},
|
|
onUpDown: function onUpDown(diff) {
|
|
_onSelect(generateConfig.addYear(value || viewDate, diff), 'key');
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
// ==================== View Operation ====================
|
|
var onYearChange = function onYearChange(diff) {
|
|
var newDate = generateConfig.addYear(viewDate, diff);
|
|
onViewDateChange(newDate);
|
|
onPanelChange(null, newDate);
|
|
};
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: panelPrefixCls
|
|
}, /*#__PURE__*/react.createElement(QuarterPanel_QuarterHeader, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onPrevYear: function onPrevYear() {
|
|
onYearChange(-1);
|
|
},
|
|
onNextYear: function onNextYear() {
|
|
onYearChange(1);
|
|
},
|
|
onYearClick: function onYearClick() {
|
|
onPanelChange('year', viewDate);
|
|
}
|
|
})), /*#__PURE__*/react.createElement(QuarterPanel_QuarterBody, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: prefixCls,
|
|
onSelect: function onSelect(date) {
|
|
_onSelect(date, 'mouse');
|
|
}
|
|
})));
|
|
}
|
|
/* harmony default export */ var panels_QuarterPanel = (QuarterPanel);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/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/rc-picker/es/panels/YearPanel/constant.js
|
|
var YEAR_DECADE_COUNT = 10;
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/YearPanel/YearHeader.js
|
|
|
|
|
|
|
|
|
|
|
|
function YearHeader(props) {
|
|
var prefixCls = props.prefixCls,
|
|
generateConfig = props.generateConfig,
|
|
viewDate = props.viewDate,
|
|
onPrevDecade = props.onPrevDecade,
|
|
onNextDecade = props.onNextDecade,
|
|
onDecadeClick = props.onDecadeClick;
|
|
var _React$useContext = react.useContext(es_PanelContext),
|
|
hideHeader = _React$useContext.hideHeader;
|
|
if (hideHeader) {
|
|
return null;
|
|
}
|
|
var headerPrefixCls = "".concat(prefixCls, "-header");
|
|
var yearNumber = generateConfig.getYear(viewDate);
|
|
var startYear = Math.floor(yearNumber / YEAR_DECADE_COUNT) * YEAR_DECADE_COUNT;
|
|
var endYear = startYear + YEAR_DECADE_COUNT - 1;
|
|
return /*#__PURE__*/react.createElement(panels_Header, (0,esm_extends/* default */.Z)({}, props, {
|
|
prefixCls: headerPrefixCls,
|
|
onSuperPrev: onPrevDecade,
|
|
onSuperNext: onNextDecade
|
|
}), /*#__PURE__*/react.createElement("button", {
|
|
type: "button",
|
|
onClick: onDecadeClick,
|
|
className: "".concat(prefixCls, "-decade-btn")
|
|
}, startYear, "-", endYear));
|
|
}
|
|
/* harmony default export */ var YearPanel_YearHeader = (YearHeader);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/panels/YearPanel/YearBody.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var YEAR_COL_COUNT = 3;
|
|
var YEAR_ROW_COUNT = 4;
|
|
function YearBody(props) {
|
|
var prefixCls = props.prefixCls,
|
|
value = props.value,
|
|
viewDate = props.viewDate,
|
|
locale = props.locale,
|
|
generateConfig = props.generateConfig,
|
|
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/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/rc-picker/es/utils/getExtraFooter.js
|
|
|
|
function getExtraFooter(prefixCls, mode, renderExtraFooter) {
|
|
if (!renderExtraFooter) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
className: "".concat(prefixCls, "-footer-extra")
|
|
}, renderExtraFooter(mode));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/getRanges.js
|
|
|
|
function getRanges(_ref) {
|
|
var prefixCls = _ref.prefixCls,
|
|
_ref$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/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`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 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/@rc-component/trigger/es/index.js + 42 modules
|
|
var es = __webpack_require__(62709);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/PickerTrigger.js
|
|
|
|
|
|
|
|
|
|
var BUILT_IN_PLACEMENTS = {
|
|
bottomLeft: {
|
|
points: ['tl', 'bl'],
|
|
offset: [0, 4],
|
|
overflow: {
|
|
adjustX: 1,
|
|
adjustY: 1
|
|
}
|
|
},
|
|
bottomRight: {
|
|
points: ['tr', 'br'],
|
|
offset: [0, 4],
|
|
overflow: {
|
|
adjustX: 1,
|
|
adjustY: 1
|
|
}
|
|
},
|
|
topLeft: {
|
|
points: ['bl', 'tl'],
|
|
offset: [0, -4],
|
|
overflow: {
|
|
adjustX: 0,
|
|
adjustY: 1
|
|
}
|
|
},
|
|
topRight: {
|
|
points: ['br', 'tr'],
|
|
offset: [0, -4],
|
|
overflow: {
|
|
adjustX: 0,
|
|
adjustY: 1
|
|
}
|
|
}
|
|
};
|
|
function PickerTrigger(_ref) {
|
|
var _classNames;
|
|
var prefixCls = _ref.prefixCls,
|
|
popupElement = _ref.popupElement,
|
|
popupStyle = _ref.popupStyle,
|
|
visible = _ref.visible,
|
|
dropdownClassName = _ref.dropdownClassName,
|
|
dropdownAlign = _ref.dropdownAlign,
|
|
transitionName = _ref.transitionName,
|
|
getPopupContainer = _ref.getPopupContainer,
|
|
children = _ref.children,
|
|
range = _ref.range,
|
|
popupPlacement = _ref.popupPlacement,
|
|
direction = _ref.direction;
|
|
var dropdownPrefixCls = "".concat(prefixCls, "-dropdown");
|
|
var getPopupPlacement = function getPopupPlacement() {
|
|
if (popupPlacement !== undefined) {
|
|
return popupPlacement;
|
|
}
|
|
return direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
|
|
};
|
|
return /*#__PURE__*/react.createElement(es/* default */.Z, {
|
|
showAction: [],
|
|
hideAction: [],
|
|
popupPlacement: getPopupPlacement(),
|
|
builtinPlacements: BUILT_IN_PLACEMENTS,
|
|
prefixCls: dropdownPrefixCls,
|
|
popupTransitionName: transitionName,
|
|
popup: popupElement,
|
|
popupAlign: dropdownAlign,
|
|
popupVisible: visible,
|
|
popupClassName: classnames_default()(dropdownClassName, (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, "".concat(dropdownPrefixCls, "-range"), range), (0,defineProperty/* default */.Z)(_classNames, "".concat(dropdownPrefixCls, "-rtl"), direction === 'rtl'), _classNames)),
|
|
popupStyle: popupStyle,
|
|
getPopupContainer: getPopupContainer
|
|
}, children);
|
|
}
|
|
/* harmony default export */ var es_PickerTrigger = (PickerTrigger);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/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() {
|
|
_onClick(value);
|
|
},
|
|
onMouseEnter: function onMouseEnter() {
|
|
onHover === null || onHover === void 0 ? void 0 : onHover(value);
|
|
},
|
|
onMouseLeave: function onMouseLeave() {
|
|
onHover === null || onHover === void 0 ? void 0 : onHover(null);
|
|
}
|
|
}, label);
|
|
})));
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/utils/warnUtil.js
|
|
|
|
function legacyPropsWarning(props) {
|
|
var picker = props.picker,
|
|
disabledHours = props.disabledHours,
|
|
disabledMinutes = props.disabledMinutes,
|
|
disabledSeconds = props.disabledSeconds;
|
|
if (picker === 'time' && (disabledHours || disabledMinutes || disabledSeconds)) {
|
|
warning(false, "'disabledHours', 'disabledMinutes', 'disabledSeconds' will be removed in the next major version, please use 'disabledTime' instead.");
|
|
}
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/Picker.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Removed:
|
|
* - getCalendarContainer: use `getPopupContainer` instead
|
|
* - onOk
|
|
*
|
|
* New Feature:
|
|
* - picker
|
|
* - allowEmpty
|
|
* - selectable
|
|
*
|
|
* Tips: Should add faq about `datetime` mode with `defaultValue`
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function InnerPicker(props) {
|
|
var _classNames2;
|
|
var _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);
|
|
}
|
|
var clearNode;
|
|
if (allowClear && mergedValue && !disabled) {
|
|
clearNode = /*#__PURE__*/react.createElement("span", {
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
},
|
|
onMouseUp: function onMouseUp(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
triggerChange(null);
|
|
triggerOpen(false);
|
|
},
|
|
className: "".concat(prefixCls, "-clear"),
|
|
role: "button"
|
|
}, clearIcon || /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-clear-btn")
|
|
}));
|
|
}
|
|
var mergedInputProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
id: id,
|
|
tabIndex: tabIndex,
|
|
disabled: disabled,
|
|
readOnly: inputReadOnly || typeof formatList[0] === 'function' || !typing,
|
|
value: hoverValue || text,
|
|
onChange: function onChange(e) {
|
|
triggerTextChange(e.target.value);
|
|
},
|
|
autoFocus: autoFocus,
|
|
placeholder: placeholder,
|
|
ref: inputRef,
|
|
title: text
|
|
}, inputProps), {}, {
|
|
size: getInputSize(picker, formatList[0], generateConfig),
|
|
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, 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/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/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/rc-picker/node_modules/rc-util/es/index.js
|
|
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./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, 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,
|
|
onChange: function onChange(nextOpen) {
|
|
onOpenChange === null || onOpenChange === void 0 ? void 0 : onOpenChange(nextOpen);
|
|
}
|
|
}),
|
|
_useMergedState2 = (0,slicedToArray/* default */.Z)(_useMergedState, 2),
|
|
mergedOpen = _useMergedState2[0],
|
|
setMergedOpen = _useMergedState2[1];
|
|
var _useMergedState3 = useMergedState(0, {
|
|
value: activePickerIndex
|
|
}),
|
|
_useMergedState4 = (0,slicedToArray/* default */.Z)(_useMergedState3, 2),
|
|
mergedActivePickerIndex = _useMergedState4[0],
|
|
setMergedActivePickerIndex = _useMergedState4[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 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 = index === 0 ? 1 : 0;
|
|
|
|
// 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) {
|
|
if (nextActiveIndex !== null) {
|
|
setFirstTimeOpen(false);
|
|
setMergedActivePickerIndex(nextActiveIndex);
|
|
}
|
|
setNextActiveIndex(null);
|
|
|
|
// Focus back
|
|
if (nextActiveIndex !== null) {
|
|
es_raf(function () {
|
|
var _ref$current;
|
|
var ref = [startInputRef, endInputRef][nextActiveIndex];
|
|
(_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
|
|
});
|
|
} else {
|
|
setMergedOpen(false);
|
|
}
|
|
} else {
|
|
setMergedOpen(false);
|
|
}
|
|
});
|
|
return [mergedOpen, mergedActivePickerIndex, firstTimeOpen, triggerOpen];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/hooks/useRangeViewDates.js
|
|
|
|
|
|
|
|
|
|
function getStartEndDistance(startDate, endDate, picker, generateConfig) {
|
|
var startNext = getClosingViewDate(startDate, picker, generateConfig, 1);
|
|
function getDistance(compareFunc) {
|
|
if (compareFunc(startDate, endDate)) {
|
|
return 'same';
|
|
}
|
|
if (compareFunc(startNext, endDate)) {
|
|
return 'closing';
|
|
}
|
|
return 'far';
|
|
}
|
|
switch (picker) {
|
|
case 'year':
|
|
return getDistance(function (start, end) {
|
|
return isSameDecade(generateConfig, start, end);
|
|
});
|
|
case 'quarter':
|
|
case 'month':
|
|
return getDistance(function (start, end) {
|
|
return isSameYear(generateConfig, start, end);
|
|
});
|
|
default:
|
|
return getDistance(function (start, end) {
|
|
return isSameMonth(generateConfig, start, end);
|
|
});
|
|
}
|
|
}
|
|
function getRangeViewDate(values, index, picker, generateConfig) {
|
|
var startDate = getValue(values, 0);
|
|
var endDate = getValue(values, 1);
|
|
if (index === 0) {
|
|
return startDate;
|
|
}
|
|
if (startDate && endDate) {
|
|
var distance = getStartEndDistance(startDate, endDate, picker, generateConfig);
|
|
switch (distance) {
|
|
case 'same':
|
|
return startDate;
|
|
case 'closing':
|
|
return startDate;
|
|
default:
|
|
return getClosingViewDate(endDate, picker, generateConfig, -1);
|
|
}
|
|
}
|
|
return startDate;
|
|
}
|
|
function useRangeViewDates(_ref) {
|
|
var values = _ref.values,
|
|
picker = _ref.picker,
|
|
defaultDates = _ref.defaultDates,
|
|
generateConfig = _ref.generateConfig;
|
|
var _React$useState = react.useState(function () {
|
|
return [getValue(defaultDates, 0), getValue(defaultDates, 1)];
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
defaultViewDates = _React$useState2[0],
|
|
setDefaultViewDates = _React$useState2[1];
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
viewDates = _React$useState4[0],
|
|
setInternalViewDates = _React$useState4[1];
|
|
var startDate = getValue(values, 0);
|
|
var endDate = getValue(values, 1);
|
|
function getViewDate(index) {
|
|
// If set default view date, use it
|
|
if (defaultViewDates[index]) {
|
|
return defaultViewDates[index];
|
|
}
|
|
return getValue(viewDates, index) || getRangeViewDate(values, index, picker, generateConfig) || startDate || endDate || generateConfig.getNow();
|
|
}
|
|
function setViewDate(viewDate, index) {
|
|
if (viewDate) {
|
|
var newViewDates = updateValues(viewDates, viewDate, index);
|
|
// Set view date will clean up default one
|
|
setDefaultViewDates(
|
|
// Should always be an array
|
|
updateValues(defaultViewDates, null, index) || [null, null]);
|
|
|
|
// Reset another one when not have value
|
|
var anotherIndex = (index + 1) % 2;
|
|
if (!getValue(values, anotherIndex)) {
|
|
newViewDates = updateValues(newViewDates, viewDate, anotherIndex);
|
|
}
|
|
setInternalViewDates(newViewDates);
|
|
} else if (startDate || endDate) {
|
|
// Reset all when has values when `viewDate` is `null` which means from open trigger
|
|
setInternalViewDates(null);
|
|
}
|
|
}
|
|
return [getViewDate, setViewDate];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-picker/es/RangePicker.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function reorderValues(values, generateConfig) {
|
|
if (values && values[0] && values[1] && generateConfig.isAfter(values[0], values[1])) {
|
|
return [values[1], values[0]];
|
|
}
|
|
return values;
|
|
}
|
|
function canValueTrigger(value, index, disabled, allowEmpty) {
|
|
if (value) {
|
|
return true;
|
|
}
|
|
if (allowEmpty && allowEmpty[index]) {
|
|
return true;
|
|
}
|
|
if (disabled[(index + 1) % 2]) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function InnerRangePicker(props) {
|
|
var _classNames2, _classNames3, _classNames4;
|
|
var _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), 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 clearNode;
|
|
if (allowClear && (getValue(mergedValue, 0) && !mergedDisabled[0] || getValue(mergedValue, 1) && !mergedDisabled[1])) {
|
|
clearNode = /*#__PURE__*/react.createElement("span", {
|
|
onMouseDown: function onMouseDown(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
},
|
|
onMouseUp: function onMouseUp(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
var values = mergedValue;
|
|
if (!mergedDisabled[0]) {
|
|
values = updateValues(values, null, 0);
|
|
}
|
|
if (!mergedDisabled[1]) {
|
|
values = updateValues(values, null, 1);
|
|
}
|
|
triggerChange(values, null);
|
|
_triggerOpen(false, mergedActivePickerIndex, 'clear');
|
|
},
|
|
className: "".concat(prefixCls, "-clear")
|
|
}, clearIcon || /*#__PURE__*/react.createElement("span", {
|
|
className: "".concat(prefixCls, "-clear-btn")
|
|
}));
|
|
}
|
|
var inputSharedProps = {
|
|
size: getInputSize(picker, formatList[0], generateConfig)
|
|
};
|
|
var activeBarLeft = 0;
|
|
var activeBarWidth = 0;
|
|
if (startInputDivRef.current && endInputDivRef.current && separatorRef.current) {
|
|
if (mergedActivePickerIndex === 0) {
|
|
activeBarWidth = startInputDivRef.current.offsetWidth;
|
|
} else {
|
|
activeBarLeft = arrowLeft;
|
|
activeBarWidth = endInputDivRef.current.offsetWidth;
|
|
}
|
|
}
|
|
var activeBarPositionStyle = direction === 'rtl' ? {
|
|
right: activeBarLeft
|
|
} : {
|
|
left: activeBarLeft
|
|
};
|
|
// ============================ Return =============================
|
|
var onContextSelect = function onContextSelect(date, type) {
|
|
var values = updateValues(selectedValue, date, mergedActivePickerIndex);
|
|
if (type === 'submit' || type !== 'key' && !needConfirmButton) {
|
|
// triggerChange will also update selected values
|
|
triggerChange(values, mergedActivePickerIndex);
|
|
// clear hover value style
|
|
if (mergedActivePickerIndex === 0) {
|
|
onStartLeave();
|
|
} else {
|
|
onEndLeave();
|
|
}
|
|
|
|
// 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, 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/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__(21816);
|
|
// 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 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,
|
|
pickerPanelCellHeight,
|
|
motionDurationSlow,
|
|
borderRadiusSM,
|
|
motionDurationMid,
|
|
controlItemBgHover,
|
|
lineWidth,
|
|
lineType,
|
|
colorPrimary,
|
|
controlItemBgActive,
|
|
colorTextLightSolid,
|
|
controlHeightSM,
|
|
pickerDateHoverRangeBorderColor,
|
|
pickerCellBorderGap,
|
|
pickerBasicCellHoverWithRangeColor,
|
|
pickerPanelCellWidth,
|
|
colorTextDisabled,
|
|
colorBgContainerDisabled
|
|
} = token;
|
|
return {
|
|
'&::before': {
|
|
position: 'absolute',
|
|
top: '50%',
|
|
insetInlineStart: 0,
|
|
insetInlineEnd: 0,
|
|
zIndex: 1,
|
|
height: pickerPanelCellHeight,
|
|
transform: 'translateY(-50%)',
|
|
transition: `all ${motionDurationSlow}`,
|
|
content: '""'
|
|
},
|
|
// >>> Default
|
|
[pickerCellInnerCls]: {
|
|
position: 'relative',
|
|
zIndex: 2,
|
|
display: 'inline-block',
|
|
minWidth: pickerPanelCellHeight,
|
|
height: pickerPanelCellHeight,
|
|
lineHeight: `${pickerPanelCellHeight}px`,
|
|
borderRadius: borderRadiusSM,
|
|
transition: `background ${motionDurationMid}, border ${motionDurationMid}`
|
|
},
|
|
// >>> 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: controlItemBgHover
|
|
}
|
|
},
|
|
// >>> 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: controlItemBgActive
|
|
}
|
|
},
|
|
// >>> 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: controlItemBgActive
|
|
}
|
|
},
|
|
[`&-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 ${pickerDateHoverRangeBorderColor}`,
|
|
borderBottom: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`,
|
|
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: pickerBasicCellHoverWithRangeColor
|
|
},
|
|
// 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: (pickerPanelCellWidth - pickerPanelCellHeight) / 2,
|
|
borderInlineStart: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`,
|
|
borderStartStartRadius: lineWidth,
|
|
borderEndStartRadius: lineWidth
|
|
},
|
|
// 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: (pickerPanelCellWidth - pickerPanelCellHeight) / 2,
|
|
borderInlineEnd: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`,
|
|
borderStartEndRadius: lineWidth,
|
|
borderEndEndRadius: lineWidth
|
|
},
|
|
// >>> Disabled
|
|
'&-disabled': {
|
|
color: colorTextDisabled,
|
|
pointerEvents: 'none',
|
|
[pickerCellInnerCls]: {
|
|
background: 'transparent'
|
|
},
|
|
'&::before': {
|
|
background: colorBgContainerDisabled
|
|
}
|
|
},
|
|
[`&-disabled${pickerCellCls}-today ${pickerCellInnerCls}::before`]: {
|
|
borderColor: colorTextDisabled
|
|
}
|
|
};
|
|
};
|
|
const genPanelStyle = token => {
|
|
const {
|
|
componentCls,
|
|
pickerCellCls,
|
|
pickerCellInnerCls,
|
|
pickerYearMonthCellWidth,
|
|
pickerControlIconSize,
|
|
pickerPanelCellWidth,
|
|
paddingSM,
|
|
paddingXS,
|
|
paddingXXS,
|
|
colorBgContainer,
|
|
lineWidth,
|
|
lineType,
|
|
borderRadiusLG,
|
|
colorPrimary,
|
|
colorTextHeading,
|
|
colorSplit,
|
|
pickerControlIconBorderWidth,
|
|
colorIcon,
|
|
pickerTextHeight,
|
|
motionDurationMid,
|
|
colorIconHover,
|
|
fontWeightStrong,
|
|
pickerPanelCellHeight,
|
|
pickerCellPaddingVertical,
|
|
colorTextDisabled,
|
|
colorText,
|
|
fontSize,
|
|
pickerBasicCellHoverWithRangeColor,
|
|
motionDurationSlow,
|
|
pickerPanelWithoutTimeCellHeight,
|
|
pickerQuarterPanelContentHeight,
|
|
colorLink,
|
|
colorLinkActive,
|
|
colorLinkHover,
|
|
pickerDateHoverRangeBorderColor,
|
|
borderRadiusSM,
|
|
colorTextLightSolid,
|
|
controlItemBgHover,
|
|
pickerTimePanelColumnHeight,
|
|
pickerTimePanelColumnWidth,
|
|
pickerTimePanelCellHeight,
|
|
controlItemBgActive,
|
|
marginXXS,
|
|
pickerDatePanelPaddingHorizontal
|
|
} = token;
|
|
const pickerPanelWidth = pickerPanelCellWidth * 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: `${pickerTextHeight}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: `${pickerTextHeight}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: pickerPanelCellHeight,
|
|
fontWeight: 'normal'
|
|
},
|
|
th: {
|
|
height: pickerPanelCellHeight + 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: pickerBasicCellHoverWithRangeColor,
|
|
transition: `all ${motionDurationSlow}`,
|
|
content: '""'
|
|
}
|
|
},
|
|
[`&-date-panel
|
|
${componentCls}-cell-in-view${componentCls}-cell-in-range${componentCls}-cell-range-hover-start
|
|
${pickerCellInnerCls}::after`]: {
|
|
insetInlineEnd: -(pickerPanelCellWidth - pickerPanelCellHeight) / 2,
|
|
insetInlineStart: 0
|
|
},
|
|
[`&-date-panel ${componentCls}-cell-in-view${componentCls}-cell-in-range${componentCls}-cell-range-hover-end ${pickerCellInnerCls}::after`]: {
|
|
insetInlineEnd: 0,
|
|
insetInlineStart: -(pickerPanelCellWidth - pickerPanelCellHeight) / 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: pickerPanelWithoutTimeCellHeight * 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 ${pickerDateHoverRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineEnd: quarterHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`
|
|
}
|
|
},
|
|
[`${componentCls}-cell-range-hover-end::after`]: {
|
|
insetInlineEnd: quarterHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineStart: quarterHoverCellFixedDistance,
|
|
borderInlineStart: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`
|
|
}
|
|
}
|
|
},
|
|
// ======================== Footer ========================
|
|
[`&-panel ${componentCls}-footer`]: {
|
|
borderTop: `${lineWidth}px ${lineType} ${colorSplit}`
|
|
},
|
|
'&-footer': {
|
|
width: 'min-content',
|
|
minWidth: '100%',
|
|
lineHeight: `${pickerTextHeight - 2 * lineWidth}px`,
|
|
textAlign: 'center',
|
|
'&-extra': {
|
|
padding: `0 ${paddingSM}`,
|
|
lineHeight: `${pickerTextHeight - 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 ${pickerDateHoverRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineEnd: commonHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`
|
|
}
|
|
},
|
|
[`${componentCls}-cell-range-hover-end::after`]: {
|
|
insetInlineEnd: commonHoverCellFixedDistance,
|
|
borderInlineEnd: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`,
|
|
[`${componentCls}-panel-rtl &`]: {
|
|
insetInlineStart: commonHoverCellFixedDistance,
|
|
borderInlineStart: `${lineWidth}px dashed ${pickerDateHoverRangeBorderColor}`
|
|
}
|
|
}
|
|
},
|
|
// ====================== 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: controlItemBgHover
|
|
}
|
|
},
|
|
[`&-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: pickerPanelCellWidth * 7,
|
|
th: {
|
|
width: pickerPanelCellWidth
|
|
}
|
|
}
|
|
},
|
|
// ==================== 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: pickerTimePanelColumnHeight
|
|
},
|
|
'&-column': {
|
|
flex: '1 0 auto',
|
|
width: pickerTimePanelColumnWidth,
|
|
margin: `${paddingXXS}px 0`,
|
|
padding: 0,
|
|
overflowY: 'hidden',
|
|
textAlign: 'start',
|
|
listStyle: 'none',
|
|
transition: `background ${motionDurationMid}`,
|
|
overflowX: 'hidden',
|
|
'&::after': {
|
|
display: 'block',
|
|
height: pickerTimePanelColumnHeight - pickerTimePanelCellHeight,
|
|
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: pickerTimePanelColumnWidth - 2 * marginXXS,
|
|
height: pickerTimePanelCellHeight,
|
|
margin: 0,
|
|
paddingBlock: 0,
|
|
paddingInlineEnd: 0,
|
|
paddingInlineStart: (pickerTimePanelColumnWidth - pickerTimePanelCellHeight) / 2,
|
|
color: colorText,
|
|
lineHeight: `${pickerTimePanelCellHeight}px`,
|
|
borderRadius: borderRadiusSM,
|
|
cursor: 'pointer',
|
|
transition: `background ${motionDurationMid}`,
|
|
'&:hover': {
|
|
background: controlItemBgHover
|
|
}
|
|
},
|
|
'&-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: pickerTimePanelColumnHeight - pickerTimePanelCellHeight + paddingXXS * 2
|
|
}
|
|
}
|
|
};
|
|
};
|
|
const genPickerStatusStyle = token => {
|
|
const {
|
|
componentCls,
|
|
colorBgContainer,
|
|
colorError,
|
|
colorErrorOutline,
|
|
colorWarning,
|
|
colorWarningOutline
|
|
} = token;
|
|
return {
|
|
[`${componentCls}:not(${componentCls}-disabled)`]: {
|
|
[`&${componentCls}-status-error`]: {
|
|
'&, &:not([disabled]):hover': {
|
|
backgroundColor: colorBgContainer,
|
|
borderColor: colorError
|
|
},
|
|
[`&${componentCls}-focused, &:focus`]: Object.assign({}, (0,style/* genActiveStyle */.M1)((0,statistic/* merge */.TS)(token, {
|
|
inputBorderActiveColor: colorError,
|
|
inputBorderHoverColor: colorError,
|
|
controlOutline: colorErrorOutline
|
|
}))),
|
|
[`${componentCls}-active-bar`]: {
|
|
background: colorError
|
|
}
|
|
},
|
|
[`&${componentCls}-status-warning`]: {
|
|
'&, &:not([disabled]):hover': {
|
|
backgroundColor: colorBgContainer,
|
|
borderColor: colorWarning
|
|
},
|
|
[`&${componentCls}-focused, &:focus`]: Object.assign({}, (0,style/* genActiveStyle */.M1)((0,statistic/* merge */.TS)(token, {
|
|
inputBorderActiveColor: colorWarning,
|
|
inputBorderHoverColor: colorWarning,
|
|
controlOutline: colorWarningOutline
|
|
}))),
|
|
[`${componentCls}-active-bar`]: {
|
|
background: colorWarning
|
|
}
|
|
}
|
|
}
|
|
};
|
|
};
|
|
const genPickerStyle = token => {
|
|
const {
|
|
componentCls,
|
|
antCls,
|
|
controlHeight,
|
|
fontSize,
|
|
inputPaddingHorizontal,
|
|
colorBgContainer,
|
|
lineWidth,
|
|
lineType,
|
|
colorBorder,
|
|
borderRadius,
|
|
motionDurationMid,
|
|
colorBgContainerDisabled,
|
|
colorTextDisabled,
|
|
colorTextPlaceholder,
|
|
controlHeightLG,
|
|
fontSizeLG,
|
|
controlHeightSM,
|
|
inputPaddingHorizontalSM,
|
|
paddingXS,
|
|
marginXS,
|
|
colorTextDescription,
|
|
lineWidthBold,
|
|
lineHeight,
|
|
colorPrimary,
|
|
motionDurationSlow,
|
|
zIndexPopup,
|
|
paddingXXS,
|
|
paddingSM,
|
|
pickerTextHeight,
|
|
controlItemBgActive,
|
|
colorPrimaryBorder,
|
|
sizePopupArrow,
|
|
borderRadiusXS,
|
|
borderRadiusOuter,
|
|
colorBgElevated,
|
|
borderRadiusLG,
|
|
boxShadowSecondary,
|
|
borderRadiusSM,
|
|
colorSplit,
|
|
controlItemBgHover,
|
|
presetsWidth,
|
|
presetsMaxWidth,
|
|
boxShadowPopoverArrow
|
|
} = token;
|
|
return [{
|
|
[componentCls]: Object.assign(Object.assign(Object.assign({}, (0,es_style/* resetComponent */.Wf)(token)), genPikerPadding(token, controlHeight, fontSize, inputPaddingHorizontal)), {
|
|
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,style/* genHoverStyle */.pU)(token)),
|
|
'&-focused': Object.assign({}, (0,style/* genActiveStyle */.M1)(token)),
|
|
[`&${componentCls}-disabled`]: {
|
|
background: colorBgContainerDisabled,
|
|
borderColor: colorBorder,
|
|
cursor: 'not-allowed',
|
|
[`${componentCls}-suffix`]: {
|
|
color: colorTextDisabled
|
|
}
|
|
},
|
|
[`&${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,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, inputPaddingHorizontal)), {
|
|
[`${componentCls}-input > input`]: {
|
|
fontSize: fontSizeLG
|
|
}
|
|
}),
|
|
'&-small': Object.assign({}, genPikerPadding(token, controlHeightSM, fontSize, inputPaddingHorizontalSM)),
|
|
[`${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: inputPaddingHorizontal
|
|
},
|
|
'&:hover': {
|
|
[`${componentCls}-clear`]: {
|
|
opacity: 1
|
|
}
|
|
},
|
|
// Active bar
|
|
[`${componentCls}-active-bar`]: {
|
|
bottom: -lineWidth,
|
|
height: lineWidthBold,
|
|
marginInlineStart: inputPaddingHorizontal,
|
|
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: inputPaddingHorizontalSM
|
|
},
|
|
[`${componentCls}-active-bar`]: {
|
|
marginInlineStart: inputPaddingHorizontalSM
|
|
}
|
|
}
|
|
},
|
|
// ======================= 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: `${pickerTextHeight - 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: controlItemBgActive,
|
|
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: inputPaddingHorizontal * 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: controlItemBgHover
|
|
}
|
|
})
|
|
}
|
|
},
|
|
// ======================== 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 pickerTimePanelCellHeight = 28;
|
|
const {
|
|
componentCls,
|
|
controlHeightLG,
|
|
controlHeightSM,
|
|
colorPrimary,
|
|
paddingXXS,
|
|
padding
|
|
} = token;
|
|
return {
|
|
pickerCellCls: `${componentCls}-cell`,
|
|
pickerCellInnerCls: `${componentCls}-cell-inner`,
|
|
pickerTextHeight: controlHeightLG,
|
|
pickerPanelCellWidth: controlHeightSM * 1.5,
|
|
pickerPanelCellHeight: controlHeightSM,
|
|
pickerDateHoverRangeBorderColor: new dist_module/* TinyColor */.C(colorPrimary).lighten(20).toHexString(),
|
|
pickerBasicCellHoverWithRangeColor: new dist_module/* TinyColor */.C(colorPrimary).lighten(35).toHexString(),
|
|
pickerPanelWithoutTimeCellHeight: controlHeightLG * 1.65,
|
|
pickerYearMonthCellWidth: controlHeightLG * 1.5,
|
|
pickerTimePanelColumnHeight: pickerTimePanelCellHeight * 8,
|
|
pickerTimePanelColumnWidth: controlHeightLG * 1.4,
|
|
pickerTimePanelCellHeight,
|
|
pickerQuarterPanelContentHeight: controlHeightLG * 1.4,
|
|
pickerCellPaddingVertical: paddingXXS + paddingXXS / 2,
|
|
pickerCellBorderGap: 2,
|
|
pickerControlIconSize: 7,
|
|
pickerControlIconBorderWidth: 1.5,
|
|
pickerDatePanelPaddingHorizontal: padding + paddingXXS / 2 // 18 in normal
|
|
};
|
|
};
|
|
// ============================== Export ==============================
|
|
/* harmony default export */ var date_picker_style = ((0,genComponentStyleHook/* default */.Z)('DatePicker', token => {
|
|
const pickerToken = (0,statistic/* merge */.TS)((0,style/* initInputToken */.e5)(token), initPickerPanelToken(token));
|
|
return [genPickerStyle(pickerToken), genPickerStatusStyle(pickerToken),
|
|
// =====================================================
|
|
// == Space Compact ==
|
|
// =====================================================
|
|
(0,compact_item/* genCompactItemStyle */.c)(token, {
|
|
focusElCls: `${token.componentCls}-focused`
|
|
})];
|
|
}, 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);
|
|
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
|
|
};
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/button/index.js
|
|
var es_button = __webpack_require__(71577);
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/PickerButton.js
|
|
|
|
|
|
function PickerButton(props) {
|
|
return /*#__PURE__*/react.createElement(es_button/* default */.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
|
|
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
|
|
} = props,
|
|
restProps = __rest(props, ["prefixCls", "getPopupContainer", "className", "placement", "size", "disabled", "bordered", "placeholder", "popupClassName", "dropdownClassName", "status"]);
|
|
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);
|
|
let additionalOverrideProps = {};
|
|
additionalOverrideProps = Object.assign(Object.assign(Object.assign({}, additionalOverrideProps), 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,
|
|
clearIcon: /*#__PURE__*/react.createElement(CloseCircleFilled/* default */.Z, null),
|
|
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`
|
|
}),
|
|
allowClear: true,
|
|
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),
|
|
locale: locale.lang,
|
|
prefixCls: prefixCls,
|
|
getPopupContainer: customGetPopupContainer || getPopupContainer,
|
|
generateConfig: generateConfig,
|
|
components: generatePicker_Components,
|
|
direction: direction,
|
|
dropdownClassName: classnames_default()(hashId, popupClassName || dropdownClassName)
|
|
})));
|
|
});
|
|
if (false) {}
|
|
return RangePicker;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/antd/es/date-picker/generatePicker/generateSinglePicker.js
|
|
var generateSinglePicker_rest = undefined && undefined.__rest || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function generatePicker(generateConfig) {
|
|
function getPicker(picker, displayName) {
|
|
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
|
|
} = props,
|
|
restProps = generateSinglePicker_rest(props, ["prefixCls", "getPopupContainer", "style", "className", "rootClassName", "size", "bordered", "placement", "placeholder", "popupClassName", "dropdownClassName", "disabled", "status"]);
|
|
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),
|
|
clearIcon: /*#__PURE__*/react.createElement(CloseCircleFilled/* default */.Z, null),
|
|
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`
|
|
}),
|
|
allowClear: true,
|
|
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)
|
|
})));
|
|
});
|
|
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
|
|
|
|
|
|
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);
|
|
|
|
/***/ }),
|
|
|
|
/***/ 27484:
|
|
/*!*****************************************!*\
|
|
!*** ./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}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 28734:
|
|
/*!*****************************************************!*\
|
|
!*** ./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)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 10285:
|
|
/*!********************************************************!*\
|
|
!*** ./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)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 96036:
|
|
/*!*************************************************!*\
|
|
!*** ./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)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 55183:
|
|
/*!*************************************************!*\
|
|
!*** ./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)}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 172:
|
|
/*!***********************************************!*\
|
|
!*** ./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}}}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6833:
|
|
/*!**********************************************!*\
|
|
!*** ./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")}}}));
|
|
|
|
/***/ })
|
|
|
|
}]); |