UNPKG

83.8 kBJavaScriptView Raw
1module.exports =
2/******/ (function(modules) { // webpackBootstrap
3/******/ // The module cache
4/******/ var installedModules = {};
5/******/
6/******/ // The require function
7/******/ function __webpack_require__(moduleId) {
8/******/
9/******/ // Check if module is in cache
10/******/ if(installedModules[moduleId]) {
11/******/ return installedModules[moduleId].exports;
12/******/ }
13/******/ // Create a new module (and put it into the cache)
14/******/ var module = installedModules[moduleId] = {
15/******/ i: moduleId,
16/******/ l: false,
17/******/ exports: {}
18/******/ };
19/******/
20/******/ // Execute the module function
21/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
22/******/
23/******/ // Flag the module as loaded
24/******/ module.l = true;
25/******/
26/******/ // Return the exports of the module
27/******/ return module.exports;
28/******/ }
29/******/
30/******/
31/******/ // expose the modules object (__webpack_modules__)
32/******/ __webpack_require__.m = modules;
33/******/
34/******/ // expose the module cache
35/******/ __webpack_require__.c = installedModules;
36/******/
37/******/ // define getter function for harmony exports
38/******/ __webpack_require__.d = function(exports, name, getter) {
39/******/ if(!__webpack_require__.o(exports, name)) {
40/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
41/******/ }
42/******/ };
43/******/
44/******/ // define __esModule on exports
45/******/ __webpack_require__.r = function(exports) {
46/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
47/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
48/******/ }
49/******/ Object.defineProperty(exports, '__esModule', { value: true });
50/******/ };
51/******/
52/******/ // create a fake namespace object
53/******/ // mode & 1: value is a module id, require it
54/******/ // mode & 2: merge all properties of value into the ns
55/******/ // mode & 4: return value when already ns object
56/******/ // mode & 8|1: behave like require
57/******/ __webpack_require__.t = function(value, mode) {
58/******/ if(mode & 1) value = __webpack_require__(value);
59/******/ if(mode & 8) return value;
60/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
61/******/ var ns = Object.create(null);
62/******/ __webpack_require__.r(ns);
63/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
64/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
65/******/ return ns;
66/******/ };
67/******/
68/******/ // getDefaultExport function for compatibility with non-harmony modules
69/******/ __webpack_require__.n = function(module) {
70/******/ var getter = module && module.__esModule ?
71/******/ function getDefault() { return module['default']; } :
72/******/ function getModuleExports() { return module; };
73/******/ __webpack_require__.d(getter, 'a', getter);
74/******/ return getter;
75/******/ };
76/******/
77/******/ // Object.prototype.hasOwnProperty.call
78/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
79/******/
80/******/ // __webpack_public_path__
81/******/ __webpack_require__.p = "/dist/";
82/******/
83/******/
84/******/ // Load entry module and return exports
85/******/ return __webpack_require__(__webpack_require__.s = 71);
86/******/ })
87/************************************************************************/
88/******/ ({
89
90/***/ 0:
91/***/ (function(module, __webpack_exports__, __webpack_require__) {
92
93"use strict";
94/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
95/* globals __VUE_SSR_CONTEXT__ */
96
97// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
98// This module is a runtime utility for cleaner component module output and will
99// be included in the final webpack user bundle.
100
101function normalizeComponent (
102 scriptExports,
103 render,
104 staticRenderFns,
105 functionalTemplate,
106 injectStyles,
107 scopeId,
108 moduleIdentifier, /* server only */
109 shadowMode /* vue-cli only */
110) {
111 // Vue.extend constructor export interop
112 var options = typeof scriptExports === 'function'
113 ? scriptExports.options
114 : scriptExports
115
116 // render functions
117 if (render) {
118 options.render = render
119 options.staticRenderFns = staticRenderFns
120 options._compiled = true
121 }
122
123 // functional template
124 if (functionalTemplate) {
125 options.functional = true
126 }
127
128 // scopedId
129 if (scopeId) {
130 options._scopeId = 'data-v-' + scopeId
131 }
132
133 var hook
134 if (moduleIdentifier) { // server build
135 hook = function (context) {
136 // 2.3 injection
137 context =
138 context || // cached call
139 (this.$vnode && this.$vnode.ssrContext) || // stateful
140 (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
141 // 2.2 with runInNewContext: true
142 if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
143 context = __VUE_SSR_CONTEXT__
144 }
145 // inject component styles
146 if (injectStyles) {
147 injectStyles.call(this, context)
148 }
149 // register component module identifier for async chunk inferrence
150 if (context && context._registeredComponents) {
151 context._registeredComponents.add(moduleIdentifier)
152 }
153 }
154 // used by ssr in case component is cached and beforeCreate
155 // never gets called
156 options._ssrRegister = hook
157 } else if (injectStyles) {
158 hook = shadowMode
159 ? function () { injectStyles.call(this, this.$root.$options.shadowRoot) }
160 : injectStyles
161 }
162
163 if (hook) {
164 if (options.functional) {
165 // for template-only hot-reload because in that case the render fn doesn't
166 // go through the normalizer
167 options._injectStyles = hook
168 // register for functioal component in vue file
169 var originalRender = options.render
170 options.render = function renderWithStyleInjection (h, context) {
171 hook.call(context)
172 return originalRender(h, context)
173 }
174 } else {
175 // inject component registration as beforeCreate hook
176 var existing = options.beforeCreate
177 options.beforeCreate = existing
178 ? [].concat(existing, hook)
179 : [hook]
180 }
181 }
182
183 return {
184 exports: scriptExports,
185 options: options
186 }
187}
188
189
190/***/ }),
191
192/***/ 1:
193/***/ (function(module, exports) {
194
195module.exports = require("element-ui/lib/utils/date-util");
196
197/***/ }),
198
199/***/ 10:
200/***/ (function(module, exports) {
201
202module.exports = require("element-ui/lib/input");
203
204/***/ }),
205
206/***/ 12:
207/***/ (function(module, exports) {
208
209module.exports = require("element-ui/lib/utils/clickoutside");
210
211/***/ }),
212
213/***/ 14:
214/***/ (function(module, exports) {
215
216module.exports = require("element-ui/lib/scrollbar");
217
218/***/ }),
219
220/***/ 2:
221/***/ (function(module, exports) {
222
223module.exports = require("element-ui/lib/utils/dom");
224
225/***/ }),
226
227/***/ 27:
228/***/ (function(module, __webpack_exports__, __webpack_require__) {
229
230"use strict";
231
232// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/panel/time.vue?vue&type=template&id=3d939089&
233var render = function() {
234 var _vm = this
235 var _h = _vm.$createElement
236 var _c = _vm._self._c || _h
237 return _c(
238 "transition",
239 {
240 attrs: { name: "el-zoom-in-top" },
241 on: {
242 "after-leave": function($event) {
243 _vm.$emit("dodestroy")
244 }
245 }
246 },
247 [
248 _c(
249 "div",
250 {
251 directives: [
252 {
253 name: "show",
254 rawName: "v-show",
255 value: _vm.visible,
256 expression: "visible"
257 }
258 ],
259 staticClass: "el-time-panel el-popper",
260 class: _vm.popperClass
261 },
262 [
263 _c(
264 "div",
265 {
266 staticClass: "el-time-panel__content",
267 class: { "has-seconds": _vm.showSeconds }
268 },
269 [
270 _c("time-spinner", {
271 ref: "spinner",
272 attrs: {
273 "arrow-control": _vm.useArrow,
274 "show-seconds": _vm.showSeconds,
275 "am-pm-mode": _vm.amPmMode,
276 date: _vm.date
277 },
278 on: {
279 change: _vm.handleChange,
280 "select-range": _vm.setSelectionRange
281 }
282 })
283 ],
284 1
285 ),
286 _c("div", { staticClass: "el-time-panel__footer" }, [
287 _c(
288 "button",
289 {
290 staticClass: "el-time-panel__btn cancel",
291 attrs: { type: "button" },
292 on: { click: _vm.handleCancel }
293 },
294 [_vm._v(_vm._s(_vm.t("el.datepicker.cancel")))]
295 ),
296 _c(
297 "button",
298 {
299 staticClass: "el-time-panel__btn",
300 class: { confirm: !_vm.disabled },
301 attrs: { type: "button" },
302 on: {
303 click: function($event) {
304 _vm.handleConfirm()
305 }
306 }
307 },
308 [_vm._v(_vm._s(_vm.t("el.datepicker.confirm")))]
309 )
310 ])
311 ]
312 )
313 ]
314 )
315}
316var staticRenderFns = []
317render._withStripped = true
318
319
320// CONCATENATED MODULE: ./packages/date-picker/src/panel/time.vue?vue&type=template&id=3d939089&
321
322// EXTERNAL MODULE: external "element-ui/lib/utils/date-util"
323var date_util_ = __webpack_require__(1);
324
325// EXTERNAL MODULE: external "element-ui/lib/mixins/locale"
326var locale_ = __webpack_require__(6);
327var locale_default = /*#__PURE__*/__webpack_require__.n(locale_);
328
329// EXTERNAL MODULE: ./packages/date-picker/src/basic/time-spinner.vue + 4 modules
330var time_spinner = __webpack_require__(35);
331
332// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/panel/time.vue?vue&type=script&lang=js&
333//
334//
335//
336//
337//
338//
339//
340//
341//
342//
343//
344//
345//
346//
347//
348//
349//
350//
351//
352//
353//
354//
355//
356//
357//
358//
359//
360//
361//
362//
363//
364//
365
366
367
368
369
370/* harmony default export */ var timevue_type_script_lang_js_ = ({
371 mixins: [locale_default.a],
372
373 components: {
374 TimeSpinner: time_spinner["a" /* default */]
375 },
376
377 props: {
378 visible: Boolean,
379 timeArrowControl: Boolean
380 },
381
382 watch: {
383 visible: function visible(val) {
384 var _this = this;
385
386 if (val) {
387 this.oldValue = this.value;
388 this.$nextTick(function () {
389 return _this.$refs.spinner.emitSelectRange('hours');
390 });
391 } else {
392 this.needInitAdjust = true;
393 }
394 },
395 value: function value(newVal) {
396 var _this2 = this;
397
398 var date = void 0;
399 if (newVal instanceof Date) {
400 date = Object(date_util_["limitTimeRange"])(newVal, this.selectableRange, this.format);
401 } else if (!newVal) {
402 date = this.defaultValue ? new Date(this.defaultValue) : new Date();
403 }
404
405 this.date = date;
406 if (this.visible && this.needInitAdjust) {
407 this.$nextTick(function (_) {
408 return _this2.adjustSpinners();
409 });
410 this.needInitAdjust = false;
411 }
412 },
413 selectableRange: function selectableRange(val) {
414 this.$refs.spinner.selectableRange = val;
415 },
416 defaultValue: function defaultValue(val) {
417 if (!Object(date_util_["isDate"])(this.value)) {
418 this.date = val ? new Date(val) : new Date();
419 }
420 }
421 },
422
423 data: function data() {
424 return {
425 popperClass: '',
426 format: 'HH:mm:ss',
427 value: '',
428 defaultValue: null,
429 date: new Date(),
430 oldValue: new Date(),
431 selectableRange: [],
432 selectionRange: [0, 2],
433 disabled: false,
434 arrowControl: false,
435 needInitAdjust: true
436 };
437 },
438
439
440 computed: {
441 showSeconds: function showSeconds() {
442 return (this.format || '').indexOf('ss') !== -1;
443 },
444 useArrow: function useArrow() {
445 return this.arrowControl || this.timeArrowControl || false;
446 },
447 amPmMode: function amPmMode() {
448 if ((this.format || '').indexOf('A') !== -1) return 'A';
449 if ((this.format || '').indexOf('a') !== -1) return 'a';
450 return '';
451 }
452 },
453
454 methods: {
455 handleCancel: function handleCancel() {
456 this.$emit('pick', this.oldValue, false);
457 },
458 handleChange: function handleChange(date) {
459 // this.visible avoids edge cases, when use scrolls during panel closing animation
460 if (this.visible) {
461 this.date = Object(date_util_["clearMilliseconds"])(date);
462 // if date is out of range, do not emit
463 if (this.isValidValue(this.date)) {
464 this.$emit('pick', this.date, true);
465 }
466 }
467 },
468 setSelectionRange: function setSelectionRange(start, end) {
469 this.$emit('select-range', start, end);
470 this.selectionRange = [start, end];
471 },
472 handleConfirm: function handleConfirm() {
473 var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
474 var first = arguments[1];
475
476 if (first) return;
477 var date = Object(date_util_["clearMilliseconds"])(Object(date_util_["limitTimeRange"])(this.date, this.selectableRange, this.format));
478 this.$emit('pick', date, visible, first);
479 },
480 handleKeydown: function handleKeydown(event) {
481 var keyCode = event.keyCode;
482 var mapping = { 38: -1, 40: 1, 37: -1, 39: 1 };
483
484 // Left or Right
485 if (keyCode === 37 || keyCode === 39) {
486 var step = mapping[keyCode];
487 this.changeSelectionRange(step);
488 event.preventDefault();
489 return;
490 }
491
492 // Up or Down
493 if (keyCode === 38 || keyCode === 40) {
494 var _step = mapping[keyCode];
495 this.$refs.spinner.scrollDown(_step);
496 event.preventDefault();
497 return;
498 }
499 },
500 isValidValue: function isValidValue(date) {
501 return Object(date_util_["timeWithinRange"])(date, this.selectableRange, this.format);
502 },
503 adjustSpinners: function adjustSpinners() {
504 return this.$refs.spinner.adjustSpinners();
505 },
506 changeSelectionRange: function changeSelectionRange(step) {
507 var list = [0, 3].concat(this.showSeconds ? [6] : []);
508 var mapping = ['hours', 'minutes'].concat(this.showSeconds ? ['seconds'] : []);
509 var index = list.indexOf(this.selectionRange[0]);
510 var next = (index + step + list.length) % list.length;
511 this.$refs.spinner.emitSelectRange(mapping[next]);
512 }
513 },
514
515 mounted: function mounted() {
516 var _this3 = this;
517
518 this.$nextTick(function () {
519 return _this3.handleConfirm(true, true);
520 });
521 this.$emit('mounted');
522 }
523});
524// CONCATENATED MODULE: ./packages/date-picker/src/panel/time.vue?vue&type=script&lang=js&
525 /* harmony default export */ var panel_timevue_type_script_lang_js_ = (timevue_type_script_lang_js_);
526// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
527var componentNormalizer = __webpack_require__(0);
528
529// CONCATENATED MODULE: ./packages/date-picker/src/panel/time.vue
530
531
532
533
534
535/* normalize component */
536
537var component = Object(componentNormalizer["a" /* default */])(
538 panel_timevue_type_script_lang_js_,
539 render,
540 staticRenderFns,
541 false,
542 null,
543 null,
544 null
545
546)
547
548/* hot reload */
549if (false) { var api; }
550component.options.__file = "packages/date-picker/src/panel/time.vue"
551/* harmony default export */ var time = __webpack_exports__["a"] = (component.exports);
552
553/***/ }),
554
555/***/ 30:
556/***/ (function(module, __webpack_exports__, __webpack_require__) {
557
558"use strict";
559/* harmony import */ var element_ui_src_utils_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
560/* harmony import */ var element_ui_src_utils_dom__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(element_ui_src_utils_dom__WEBPACK_IMPORTED_MODULE_0__);
561
562
563/* harmony default export */ __webpack_exports__["a"] = ({
564 bind: function bind(el, binding, vnode) {
565 var interval = null;
566 var startTime = void 0;
567 var handler = function handler() {
568 return vnode.context[binding.expression].apply();
569 };
570 var clear = function clear() {
571 if (Date.now() - startTime < 100) {
572 handler();
573 }
574 clearInterval(interval);
575 interval = null;
576 };
577
578 Object(element_ui_src_utils_dom__WEBPACK_IMPORTED_MODULE_0__["on"])(el, 'mousedown', function (e) {
579 if (e.button !== 0) return;
580 startTime = Date.now();
581 Object(element_ui_src_utils_dom__WEBPACK_IMPORTED_MODULE_0__["once"])(document, 'mouseup', clear);
582 clearInterval(interval);
583 interval = setInterval(handler, 100);
584 });
585 }
586});
587
588/***/ }),
589
590/***/ 33:
591/***/ (function(module, __webpack_exports__, __webpack_require__) {
592
593"use strict";
594
595// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/picker.vue?vue&type=template&id=79ae069f&
596var render = function() {
597 var _vm = this
598 var _h = _vm.$createElement
599 var _c = _vm._self._c || _h
600 return !_vm.ranged
601 ? _c(
602 "el-input",
603 _vm._b(
604 {
605 directives: [
606 {
607 name: "clickoutside",
608 rawName: "v-clickoutside",
609 value: _vm.handleClose,
610 expression: "handleClose"
611 }
612 ],
613 ref: "reference",
614 staticClass: "el-date-editor",
615 class: "el-date-editor--" + _vm.type,
616 attrs: {
617 readonly:
618 !_vm.editable ||
619 _vm.readonly ||
620 _vm.type === "dates" ||
621 _vm.type === "week",
622 disabled: _vm.pickerDisabled,
623 size: _vm.pickerSize,
624 name: _vm.name,
625 placeholder: _vm.placeholder,
626 value: _vm.displayValue,
627 validateEvent: false
628 },
629 on: {
630 focus: _vm.handleFocus,
631 input: function(value) {
632 return (_vm.userInput = value)
633 },
634 change: _vm.handleChange
635 },
636 nativeOn: {
637 keydown: function($event) {
638 return _vm.handleKeydown($event)
639 },
640 mouseenter: function($event) {
641 return _vm.handleMouseEnter($event)
642 },
643 mouseleave: function($event) {
644 _vm.showClose = false
645 }
646 }
647 },
648 "el-input",
649 _vm.firstInputId,
650 false
651 ),
652 [
653 _c("i", {
654 staticClass: "el-input__icon",
655 class: _vm.triggerClass,
656 attrs: { slot: "prefix" },
657 on: { click: _vm.handleFocus },
658 slot: "prefix"
659 }),
660 _vm.haveTrigger
661 ? _c("i", {
662 staticClass: "el-input__icon",
663 class: [_vm.showClose ? "" + _vm.clearIcon : ""],
664 attrs: { slot: "suffix" },
665 on: { click: _vm.handleClickIcon },
666 slot: "suffix"
667 })
668 : _vm._e()
669 ]
670 )
671 : _c(
672 "div",
673 {
674 directives: [
675 {
676 name: "clickoutside",
677 rawName: "v-clickoutside",
678 value: _vm.handleClose,
679 expression: "handleClose"
680 }
681 ],
682 ref: "reference",
683 staticClass: "el-date-editor el-range-editor el-input__inner",
684 class: [
685 "el-date-editor--" + _vm.type,
686 _vm.pickerSize ? "el-range-editor--" + _vm.pickerSize : "",
687 _vm.pickerDisabled ? "is-disabled" : "",
688 _vm.pickerVisible ? "is-active" : ""
689 ],
690 on: {
691 click: _vm.handleRangeClick,
692 mouseenter: _vm.handleMouseEnter,
693 mouseleave: function($event) {
694 _vm.showClose = false
695 },
696 keydown: _vm.handleKeydown
697 }
698 },
699 [
700 _c("i", {
701 class: ["el-input__icon", "el-range__icon", _vm.triggerClass]
702 }),
703 _c(
704 "input",
705 _vm._b(
706 {
707 staticClass: "el-range-input",
708 attrs: {
709 autocomplete: "off",
710 placeholder: _vm.startPlaceholder,
711 disabled: _vm.pickerDisabled,
712 readonly: !_vm.editable || _vm.readonly,
713 name: _vm.name && _vm.name[0]
714 },
715 domProps: { value: _vm.displayValue && _vm.displayValue[0] },
716 on: {
717 input: _vm.handleStartInput,
718 change: _vm.handleStartChange,
719 focus: _vm.handleFocus
720 }
721 },
722 "input",
723 _vm.firstInputId,
724 false
725 )
726 ),
727 _vm._t("range-separator", [
728 _c("span", { staticClass: "el-range-separator" }, [
729 _vm._v(_vm._s(_vm.rangeSeparator))
730 ])
731 ]),
732 _c(
733 "input",
734 _vm._b(
735 {
736 staticClass: "el-range-input",
737 attrs: {
738 autocomplete: "off",
739 placeholder: _vm.endPlaceholder,
740 disabled: _vm.pickerDisabled,
741 readonly: !_vm.editable || _vm.readonly,
742 name: _vm.name && _vm.name[1]
743 },
744 domProps: { value: _vm.displayValue && _vm.displayValue[1] },
745 on: {
746 input: _vm.handleEndInput,
747 change: _vm.handleEndChange,
748 focus: _vm.handleFocus
749 }
750 },
751 "input",
752 _vm.secondInputId,
753 false
754 )
755 ),
756 _vm.haveTrigger
757 ? _c("i", {
758 staticClass: "el-input__icon el-range__close-icon",
759 class: [_vm.showClose ? "" + _vm.clearIcon : ""],
760 on: { click: _vm.handleClickIcon }
761 })
762 : _vm._e()
763 ],
764 2
765 )
766}
767var staticRenderFns = []
768render._withStripped = true
769
770
771// CONCATENATED MODULE: ./packages/date-picker/src/picker.vue?vue&type=template&id=79ae069f&
772
773// EXTERNAL MODULE: external "vue"
774var external_vue_ = __webpack_require__(7);
775var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_);
776
777// EXTERNAL MODULE: external "element-ui/lib/utils/clickoutside"
778var clickoutside_ = __webpack_require__(12);
779var clickoutside_default = /*#__PURE__*/__webpack_require__.n(clickoutside_);
780
781// EXTERNAL MODULE: external "element-ui/lib/utils/date-util"
782var date_util_ = __webpack_require__(1);
783
784// EXTERNAL MODULE: external "element-ui/lib/utils/vue-popper"
785var vue_popper_ = __webpack_require__(5);
786var vue_popper_default = /*#__PURE__*/__webpack_require__.n(vue_popper_);
787
788// EXTERNAL MODULE: external "element-ui/lib/mixins/emitter"
789var emitter_ = __webpack_require__(4);
790var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);
791
792// EXTERNAL MODULE: external "element-ui/lib/input"
793var input_ = __webpack_require__(10);
794var input_default = /*#__PURE__*/__webpack_require__.n(input_);
795
796// EXTERNAL MODULE: external "element-ui/lib/utils/merge"
797var merge_ = __webpack_require__(9);
798var merge_default = /*#__PURE__*/__webpack_require__.n(merge_);
799
800// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/picker.vue?vue&type=script&lang=js&
801//
802//
803//
804//
805//
806//
807//
808//
809//
810//
811//
812//
813//
814//
815//
816//
817//
818//
819//
820//
821//
822//
823//
824//
825//
826//
827//
828//
829//
830//
831//
832//
833//
834//
835//
836//
837//
838//
839//
840//
841//
842//
843//
844//
845//
846//
847//
848//
849//
850//
851//
852//
853//
854//
855//
856//
857//
858//
859//
860//
861//
862//
863//
864//
865//
866//
867//
868//
869//
870//
871//
872//
873//
874//
875//
876//
877//
878//
879//
880//
881//
882//
883//
884//
885//
886
887
888
889
890
891
892
893
894
895var NewPopper = {
896 props: {
897 appendToBody: vue_popper_default.a.props.appendToBody,
898 offset: vue_popper_default.a.props.offset,
899 boundariesPadding: vue_popper_default.a.props.boundariesPadding,
900 arrowOffset: vue_popper_default.a.props.arrowOffset
901 },
902 methods: vue_popper_default.a.methods,
903 data: function data() {
904 return merge_default()({ visibleArrow: true }, vue_popper_default.a.data);
905 },
906
907 beforeDestroy: vue_popper_default.a.beforeDestroy
908};
909
910var DEFAULT_FORMATS = {
911 date: 'yyyy-MM-dd',
912 month: 'yyyy-MM',
913 datetime: 'yyyy-MM-dd HH:mm:ss',
914 time: 'HH:mm:ss',
915 week: 'yyyywWW',
916 timerange: 'HH:mm:ss',
917 daterange: 'yyyy-MM-dd',
918 monthrange: 'yyyy-MM',
919 datetimerange: 'yyyy-MM-dd HH:mm:ss',
920 year: 'yyyy'
921};
922var HAVE_TRIGGER_TYPES = ['date', 'datetime', 'time', 'time-select', 'week', 'month', 'year', 'daterange', 'monthrange', 'timerange', 'datetimerange', 'dates'];
923var pickervue_type_script_lang_js_DATE_FORMATTER = function DATE_FORMATTER(value, format) {
924 if (format === 'timestamp') return value.getTime();
925 return Object(date_util_["formatDate"])(value, format);
926};
927var pickervue_type_script_lang_js_DATE_PARSER = function DATE_PARSER(text, format) {
928 if (format === 'timestamp') return new Date(Number(text));
929 return Object(date_util_["parseDate"])(text, format);
930};
931var RANGE_FORMATTER = function RANGE_FORMATTER(value, format) {
932 if (Array.isArray(value) && value.length === 2) {
933 var start = value[0];
934 var end = value[1];
935
936 if (start && end) {
937 return [pickervue_type_script_lang_js_DATE_FORMATTER(start, format), pickervue_type_script_lang_js_DATE_FORMATTER(end, format)];
938 }
939 }
940 return '';
941};
942var RANGE_PARSER = function RANGE_PARSER(array, format, separator) {
943 if (!Array.isArray(array)) {
944 array = array.split(separator);
945 }
946 if (array.length === 2) {
947 var range1 = array[0];
948 var range2 = array[1];
949
950 return [pickervue_type_script_lang_js_DATE_PARSER(range1, format), pickervue_type_script_lang_js_DATE_PARSER(range2, format)];
951 }
952 return [];
953};
954var TYPE_VALUE_RESOLVER_MAP = {
955 default: {
956 formatter: function formatter(value) {
957 if (!value) return '';
958 return '' + value;
959 },
960 parser: function parser(text) {
961 if (text === undefined || text === '') return null;
962 return text;
963 }
964 },
965 week: {
966 formatter: function formatter(value, format) {
967 var week = Object(date_util_["getWeekNumber"])(value);
968 var month = value.getMonth();
969 var trueDate = new Date(value);
970 if (week === 1 && month === 11) {
971 trueDate.setHours(0, 0, 0, 0);
972 trueDate.setDate(trueDate.getDate() + 3 - (trueDate.getDay() + 6) % 7);
973 }
974 var date = Object(date_util_["formatDate"])(trueDate, format);
975
976 date = /WW/.test(date) ? date.replace(/WW/, week < 10 ? '0' + week : week) : date.replace(/W/, week);
977 return date;
978 },
979 parser: function parser(text, format) {
980 // parse as if a normal date
981 return TYPE_VALUE_RESOLVER_MAP.date.parser(text, format);
982 }
983 },
984 date: {
985 formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
986 parser: pickervue_type_script_lang_js_DATE_PARSER
987 },
988 datetime: {
989 formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
990 parser: pickervue_type_script_lang_js_DATE_PARSER
991 },
992 daterange: {
993 formatter: RANGE_FORMATTER,
994 parser: RANGE_PARSER
995 },
996 monthrange: {
997 formatter: RANGE_FORMATTER,
998 parser: RANGE_PARSER
999 },
1000 datetimerange: {
1001 formatter: RANGE_FORMATTER,
1002 parser: RANGE_PARSER
1003 },
1004 timerange: {
1005 formatter: RANGE_FORMATTER,
1006 parser: RANGE_PARSER
1007 },
1008 time: {
1009 formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
1010 parser: pickervue_type_script_lang_js_DATE_PARSER
1011 },
1012 month: {
1013 formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
1014 parser: pickervue_type_script_lang_js_DATE_PARSER
1015 },
1016 year: {
1017 formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
1018 parser: pickervue_type_script_lang_js_DATE_PARSER
1019 },
1020 number: {
1021 formatter: function formatter(value) {
1022 if (!value) return '';
1023 return '' + value;
1024 },
1025 parser: function parser(text) {
1026 var result = Number(text);
1027
1028 if (!isNaN(text)) {
1029 return result;
1030 } else {
1031 return null;
1032 }
1033 }
1034 },
1035 dates: {
1036 formatter: function formatter(value, format) {
1037 return value.map(function (date) {
1038 return pickervue_type_script_lang_js_DATE_FORMATTER(date, format);
1039 });
1040 },
1041 parser: function parser(value, format) {
1042 return (typeof value === 'string' ? value.split(', ') : value).map(function (date) {
1043 return date instanceof Date ? date : pickervue_type_script_lang_js_DATE_PARSER(date, format);
1044 });
1045 }
1046 }
1047};
1048var PLACEMENT_MAP = {
1049 left: 'bottom-start',
1050 center: 'bottom',
1051 right: 'bottom-end'
1052};
1053
1054var parseAsFormatAndType = function parseAsFormatAndType(value, customFormat, type) {
1055 var rangeSeparator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '-';
1056
1057 if (!value) return null;
1058 var parser = (TYPE_VALUE_RESOLVER_MAP[type] || TYPE_VALUE_RESOLVER_MAP['default']).parser;
1059 var format = customFormat || DEFAULT_FORMATS[type];
1060 return parser(value, format, rangeSeparator);
1061};
1062
1063var formatAsFormatAndType = function formatAsFormatAndType(value, customFormat, type) {
1064 if (!value) return null;
1065 var formatter = (TYPE_VALUE_RESOLVER_MAP[type] || TYPE_VALUE_RESOLVER_MAP['default']).formatter;
1066 var format = customFormat || DEFAULT_FORMATS[type];
1067 return formatter(value, format);
1068};
1069
1070/*
1071 * Considers:
1072 * 1. Date object
1073 * 2. date string
1074 * 3. array of 1 or 2
1075 */
1076var valueEquals = function valueEquals(a, b) {
1077 // considers Date object and string
1078 var dateEquals = function dateEquals(a, b) {
1079 var aIsDate = a instanceof Date;
1080 var bIsDate = b instanceof Date;
1081 if (aIsDate && bIsDate) {
1082 return a.getTime() === b.getTime();
1083 }
1084 if (!aIsDate && !bIsDate) {
1085 return a === b;
1086 }
1087 return false;
1088 };
1089
1090 var aIsArray = a instanceof Array;
1091 var bIsArray = b instanceof Array;
1092 if (aIsArray && bIsArray) {
1093 if (a.length !== b.length) {
1094 return false;
1095 }
1096 return a.every(function (item, index) {
1097 return dateEquals(item, b[index]);
1098 });
1099 }
1100 if (!aIsArray && !bIsArray) {
1101 return dateEquals(a, b);
1102 }
1103 return false;
1104};
1105
1106var isString = function isString(val) {
1107 return typeof val === 'string' || val instanceof String;
1108};
1109
1110var validator = function validator(val) {
1111 // either: String, Array of String, null / undefined
1112 return val === null || val === undefined || isString(val) || Array.isArray(val) && val.length === 2 && val.every(isString);
1113};
1114
1115/* harmony default export */ var pickervue_type_script_lang_js_ = ({
1116 mixins: [emitter_default.a, NewPopper],
1117
1118 inject: {
1119 elForm: {
1120 default: ''
1121 },
1122 elFormItem: {
1123 default: ''
1124 }
1125 },
1126
1127 props: {
1128 size: String,
1129 format: String,
1130 valueFormat: String,
1131 readonly: Boolean,
1132 placeholder: String,
1133 startPlaceholder: String,
1134 endPlaceholder: String,
1135 prefixIcon: String,
1136 clearIcon: {
1137 type: String,
1138 default: 'el-icon-circle-close'
1139 },
1140 name: {
1141 default: '',
1142 validator: validator
1143 },
1144 disabled: Boolean,
1145 clearable: {
1146 type: Boolean,
1147 default: true
1148 },
1149 id: {
1150 default: '',
1151 validator: validator
1152 },
1153 popperClass: String,
1154 editable: {
1155 type: Boolean,
1156 default: true
1157 },
1158 align: {
1159 type: String,
1160 default: 'left'
1161 },
1162 value: {},
1163 defaultValue: {},
1164 defaultTime: {},
1165 rangeSeparator: {
1166 default: '-'
1167 },
1168 pickerOptions: {},
1169 unlinkPanels: Boolean,
1170 validateEvent: {
1171 type: Boolean,
1172 default: true
1173 }
1174 },
1175
1176 components: { ElInput: input_default.a },
1177
1178 directives: { Clickoutside: clickoutside_default.a },
1179
1180 data: function data() {
1181 return {
1182 pickerVisible: false,
1183 showClose: false,
1184 userInput: null,
1185 valueOnOpen: null, // value when picker opens, used to determine whether to emit change
1186 unwatchPickerOptions: null
1187 };
1188 },
1189
1190
1191 watch: {
1192 pickerVisible: function pickerVisible(val) {
1193 if (this.readonly || this.pickerDisabled) return;
1194 if (val) {
1195 this.showPicker();
1196 this.valueOnOpen = Array.isArray(this.value) ? [].concat(this.value) : this.value;
1197 } else {
1198 this.hidePicker();
1199 this.emitChange(this.value);
1200 this.userInput = null;
1201 if (this.validateEvent) {
1202 this.dispatch('ElFormItem', 'el.form.blur');
1203 }
1204 this.$emit('blur', this);
1205 this.blur();
1206 }
1207 },
1208
1209 parsedValue: {
1210 immediate: true,
1211 handler: function handler(val) {
1212 if (this.picker) {
1213 this.picker.value = val;
1214 }
1215 }
1216 },
1217 defaultValue: function defaultValue(val) {
1218 // NOTE: should eventually move to jsx style picker + panel ?
1219 if (this.picker) {
1220 this.picker.defaultValue = val;
1221 }
1222 },
1223 value: function value(val, oldVal) {
1224 if (!valueEquals(val, oldVal) && !this.pickerVisible && this.validateEvent) {
1225 this.dispatch('ElFormItem', 'el.form.change', val);
1226 }
1227 }
1228 },
1229
1230 computed: {
1231 ranged: function ranged() {
1232 return this.type.indexOf('range') > -1;
1233 },
1234 reference: function reference() {
1235 var reference = this.$refs.reference;
1236 return reference.$el || reference;
1237 },
1238 refInput: function refInput() {
1239 if (this.reference) {
1240 return [].slice.call(this.reference.querySelectorAll('input'));
1241 }
1242 return [];
1243 },
1244 valueIsEmpty: function valueIsEmpty() {
1245 var val = this.value;
1246 if (Array.isArray(val)) {
1247 for (var i = 0, len = val.length; i < len; i++) {
1248 if (val[i]) {
1249 return false;
1250 }
1251 }
1252 } else {
1253 if (val) {
1254 return false;
1255 }
1256 }
1257 return true;
1258 },
1259 triggerClass: function triggerClass() {
1260 return this.prefixIcon || (this.type.indexOf('time') !== -1 ? 'el-icon-time' : 'el-icon-date');
1261 },
1262 selectionMode: function selectionMode() {
1263 if (this.type === 'week') {
1264 return 'week';
1265 } else if (this.type === 'month') {
1266 return 'month';
1267 } else if (this.type === 'year') {
1268 return 'year';
1269 } else if (this.type === 'dates') {
1270 return 'dates';
1271 }
1272
1273 return 'day';
1274 },
1275 haveTrigger: function haveTrigger() {
1276 if (typeof this.showTrigger !== 'undefined') {
1277 return this.showTrigger;
1278 }
1279 return HAVE_TRIGGER_TYPES.indexOf(this.type) !== -1;
1280 },
1281 displayValue: function displayValue() {
1282 var formattedValue = formatAsFormatAndType(this.parsedValue, this.format, this.type, this.rangeSeparator);
1283 if (Array.isArray(this.userInput)) {
1284 return [this.userInput[0] || formattedValue && formattedValue[0] || '', this.userInput[1] || formattedValue && formattedValue[1] || ''];
1285 } else if (this.userInput !== null) {
1286 return this.userInput;
1287 } else if (formattedValue) {
1288 return this.type === 'dates' ? formattedValue.join(', ') : formattedValue;
1289 } else {
1290 return '';
1291 }
1292 },
1293 parsedValue: function parsedValue() {
1294 if (!this.value) return this.value; // component value is not set
1295 if (this.type === 'time-select') return this.value; // time-select does not require parsing, this might change in next major version
1296
1297 var valueIsDateObject = Object(date_util_["isDateObject"])(this.value) || Array.isArray(this.value) && this.value.every(date_util_["isDateObject"]);
1298 if (valueIsDateObject) {
1299 return this.value;
1300 }
1301
1302 if (this.valueFormat) {
1303 return parseAsFormatAndType(this.value, this.valueFormat, this.type, this.rangeSeparator) || this.value;
1304 }
1305
1306 // NOTE: deal with common but incorrect usage, should remove in next major version
1307 // user might provide string / timestamp without value-format, coerce them into date (or array of date)
1308 return Array.isArray(this.value) ? this.value.map(function (val) {
1309 return new Date(val);
1310 }) : new Date(this.value);
1311 },
1312 _elFormItemSize: function _elFormItemSize() {
1313 return (this.elFormItem || {}).elFormItemSize;
1314 },
1315 pickerSize: function pickerSize() {
1316 return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
1317 },
1318 pickerDisabled: function pickerDisabled() {
1319 return this.disabled || (this.elForm || {}).disabled;
1320 },
1321 firstInputId: function firstInputId() {
1322 var obj = {};
1323 var id = void 0;
1324 if (this.ranged) {
1325 id = this.id && this.id[0];
1326 } else {
1327 id = this.id;
1328 }
1329 if (id) obj.id = id;
1330 return obj;
1331 },
1332 secondInputId: function secondInputId() {
1333 var obj = {};
1334 var id = void 0;
1335 if (this.ranged) {
1336 id = this.id && this.id[1];
1337 }
1338 if (id) obj.id = id;
1339 return obj;
1340 }
1341 },
1342
1343 created: function created() {
1344 // vue-popper
1345 this.popperOptions = {
1346 boundariesPadding: 0,
1347 gpuAcceleration: false
1348 };
1349 this.placement = PLACEMENT_MAP[this.align] || PLACEMENT_MAP.left;
1350
1351 this.$on('fieldReset', this.handleFieldReset);
1352 },
1353
1354
1355 methods: {
1356 focus: function focus() {
1357 if (!this.ranged) {
1358 this.$refs.reference.focus();
1359 } else {
1360 this.handleFocus();
1361 }
1362 },
1363 blur: function blur() {
1364 this.refInput.forEach(function (input) {
1365 return input.blur();
1366 });
1367 },
1368
1369
1370 // {parse, formatTo} Value deals maps component value with internal Date
1371 parseValue: function parseValue(value) {
1372 var isParsed = Object(date_util_["isDateObject"])(value) || Array.isArray(value) && value.every(date_util_["isDateObject"]);
1373 if (this.valueFormat && !isParsed) {
1374 return parseAsFormatAndType(value, this.valueFormat, this.type, this.rangeSeparator) || value;
1375 } else {
1376 return value;
1377 }
1378 },
1379 formatToValue: function formatToValue(date) {
1380 var isFormattable = Object(date_util_["isDateObject"])(date) || Array.isArray(date) && date.every(date_util_["isDateObject"]);
1381 if (this.valueFormat && isFormattable) {
1382 return formatAsFormatAndType(date, this.valueFormat, this.type, this.rangeSeparator);
1383 } else {
1384 return date;
1385 }
1386 },
1387
1388
1389 // {parse, formatTo} String deals with user input
1390 parseString: function parseString(value) {
1391 var type = Array.isArray(value) ? this.type : this.type.replace('range', '');
1392 return parseAsFormatAndType(value, this.format, type);
1393 },
1394 formatToString: function formatToString(value) {
1395 var type = Array.isArray(value) ? this.type : this.type.replace('range', '');
1396 return formatAsFormatAndType(value, this.format, type);
1397 },
1398 handleMouseEnter: function handleMouseEnter() {
1399 if (this.readonly || this.pickerDisabled) return;
1400 if (!this.valueIsEmpty && this.clearable) {
1401 this.showClose = true;
1402 }
1403 },
1404 handleChange: function handleChange() {
1405 if (this.userInput) {
1406 var value = this.parseString(this.displayValue);
1407 if (value) {
1408 this.picker.value = value;
1409 if (this.isValidValue(value)) {
1410 this.emitInput(value);
1411 this.userInput = null;
1412 }
1413 }
1414 }
1415 if (this.userInput === '') {
1416 this.emitInput(null);
1417 this.emitChange(null);
1418 this.userInput = null;
1419 }
1420 },
1421 handleStartInput: function handleStartInput(event) {
1422 if (this.userInput) {
1423 this.userInput = [event.target.value, this.userInput[1]];
1424 } else {
1425 this.userInput = [event.target.value, null];
1426 }
1427 },
1428 handleEndInput: function handleEndInput(event) {
1429 if (this.userInput) {
1430 this.userInput = [this.userInput[0], event.target.value];
1431 } else {
1432 this.userInput = [null, event.target.value];
1433 }
1434 },
1435 handleStartChange: function handleStartChange(event) {
1436 var value = this.parseString(this.userInput && this.userInput[0]);
1437 if (value) {
1438 this.userInput = [this.formatToString(value), this.displayValue[1]];
1439 var newValue = [value, this.picker.value && this.picker.value[1]];
1440 this.picker.value = newValue;
1441 if (this.isValidValue(newValue)) {
1442 this.emitInput(newValue);
1443 this.userInput = null;
1444 }
1445 }
1446 },
1447 handleEndChange: function handleEndChange(event) {
1448 var value = this.parseString(this.userInput && this.userInput[1]);
1449 if (value) {
1450 this.userInput = [this.displayValue[0], this.formatToString(value)];
1451 var newValue = [this.picker.value && this.picker.value[0], value];
1452 this.picker.value = newValue;
1453 if (this.isValidValue(newValue)) {
1454 this.emitInput(newValue);
1455 this.userInput = null;
1456 }
1457 }
1458 },
1459 handleClickIcon: function handleClickIcon(event) {
1460 if (this.readonly || this.pickerDisabled) return;
1461 if (this.showClose) {
1462 this.valueOnOpen = this.value;
1463 event.stopPropagation();
1464 this.emitInput(null);
1465 this.emitChange(null);
1466 this.showClose = false;
1467 if (this.picker && typeof this.picker.handleClear === 'function') {
1468 this.picker.handleClear();
1469 }
1470 } else {
1471 this.pickerVisible = !this.pickerVisible;
1472 }
1473 },
1474 handleClose: function handleClose() {
1475 if (!this.pickerVisible) return;
1476 this.pickerVisible = false;
1477
1478 if (this.type === 'dates') {
1479 // restore to former value
1480 var oldValue = parseAsFormatAndType(this.valueOnOpen, this.valueFormat, this.type, this.rangeSeparator) || this.valueOnOpen;
1481 this.emitInput(oldValue);
1482 }
1483 },
1484 handleFieldReset: function handleFieldReset(initialValue) {
1485 this.userInput = initialValue === '' ? null : initialValue;
1486 },
1487 handleFocus: function handleFocus() {
1488 var type = this.type;
1489
1490 if (HAVE_TRIGGER_TYPES.indexOf(type) !== -1 && !this.pickerVisible) {
1491 this.pickerVisible = true;
1492 }
1493 this.$emit('focus', this);
1494 },
1495 handleKeydown: function handleKeydown(event) {
1496 var _this = this;
1497
1498 var keyCode = event.keyCode;
1499
1500 // ESC
1501 if (keyCode === 27) {
1502 this.pickerVisible = false;
1503 event.stopPropagation();
1504 return;
1505 }
1506
1507 // Tab
1508 if (keyCode === 9) {
1509 if (!this.ranged) {
1510 this.handleChange();
1511 this.pickerVisible = this.picker.visible = false;
1512 this.blur();
1513 event.stopPropagation();
1514 } else {
1515 // user may change focus between two input
1516 setTimeout(function () {
1517 if (_this.refInput.indexOf(document.activeElement) === -1) {
1518 _this.pickerVisible = false;
1519 _this.blur();
1520 event.stopPropagation();
1521 }
1522 }, 0);
1523 }
1524 return;
1525 }
1526
1527 // Enter
1528 if (keyCode === 13) {
1529 if (this.userInput === '' || this.isValidValue(this.parseString(this.displayValue))) {
1530 this.handleChange();
1531 this.pickerVisible = this.picker.visible = false;
1532 this.blur();
1533 }
1534 event.stopPropagation();
1535 return;
1536 }
1537
1538 // if user is typing, do not let picker handle key input
1539 if (this.userInput) {
1540 event.stopPropagation();
1541 return;
1542 }
1543
1544 // delegate other keys to panel
1545 if (this.picker && this.picker.handleKeydown) {
1546 this.picker.handleKeydown(event);
1547 }
1548 },
1549 handleRangeClick: function handleRangeClick() {
1550 var type = this.type;
1551
1552 if (HAVE_TRIGGER_TYPES.indexOf(type) !== -1 && !this.pickerVisible) {
1553 this.pickerVisible = true;
1554 }
1555 this.$emit('focus', this);
1556 },
1557 hidePicker: function hidePicker() {
1558 if (this.picker) {
1559 this.picker.resetView && this.picker.resetView();
1560 this.pickerVisible = this.picker.visible = false;
1561 this.destroyPopper();
1562 }
1563 },
1564 showPicker: function showPicker() {
1565 var _this2 = this;
1566
1567 if (this.$isServer) return;
1568 if (!this.picker) {
1569 this.mountPicker();
1570 }
1571 this.pickerVisible = this.picker.visible = true;
1572
1573 this.updatePopper();
1574
1575 this.picker.value = this.parsedValue;
1576 this.picker.resetView && this.picker.resetView();
1577
1578 this.$nextTick(function () {
1579 _this2.picker.adjustSpinners && _this2.picker.adjustSpinners();
1580 });
1581 },
1582 mountPicker: function mountPicker() {
1583 var _this3 = this;
1584
1585 this.picker = new external_vue_default.a(this.panel).$mount();
1586 this.picker.defaultValue = this.defaultValue;
1587 this.picker.defaultTime = this.defaultTime;
1588 this.picker.popperClass = this.popperClass;
1589 this.popperElm = this.picker.$el;
1590 this.picker.width = this.reference.getBoundingClientRect().width;
1591 this.picker.showTime = this.type === 'datetime' || this.type === 'datetimerange';
1592 this.picker.selectionMode = this.selectionMode;
1593 this.picker.unlinkPanels = this.unlinkPanels;
1594 this.picker.arrowControl = this.arrowControl || this.timeArrowControl || false;
1595 this.$watch('format', function (format) {
1596 _this3.picker.format = format;
1597 });
1598
1599 var updateOptions = function updateOptions() {
1600 var options = _this3.pickerOptions;
1601
1602 if (options && options.selectableRange) {
1603 var ranges = options.selectableRange;
1604 var parser = TYPE_VALUE_RESOLVER_MAP.datetimerange.parser;
1605 var format = DEFAULT_FORMATS.timerange;
1606
1607 ranges = Array.isArray(ranges) ? ranges : [ranges];
1608 _this3.picker.selectableRange = ranges.map(function (range) {
1609 return parser(range, format, _this3.rangeSeparator);
1610 });
1611 }
1612
1613 for (var option in options) {
1614 if (options.hasOwnProperty(option) &&
1615 // 忽略 time-picker 的该配置项
1616 option !== 'selectableRange') {
1617 _this3.picker[option] = options[option];
1618 }
1619 }
1620
1621 // main format must prevail over undocumented pickerOptions.format
1622 if (_this3.format) {
1623 _this3.picker.format = _this3.format;
1624 }
1625 };
1626 updateOptions();
1627 this.unwatchPickerOptions = this.$watch('pickerOptions', function () {
1628 return updateOptions();
1629 }, { deep: true });
1630 this.$el.appendChild(this.picker.$el);
1631 this.picker.resetView && this.picker.resetView();
1632
1633 this.picker.$on('dodestroy', this.doDestroy);
1634 this.picker.$on('pick', function () {
1635 var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
1636 var visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
1637
1638 _this3.userInput = null;
1639 _this3.pickerVisible = _this3.picker.visible = visible;
1640 _this3.emitInput(date);
1641 _this3.picker.resetView && _this3.picker.resetView();
1642 });
1643
1644 this.picker.$on('select-range', function (start, end, pos) {
1645 if (_this3.refInput.length === 0) return;
1646 if (!pos || pos === 'min') {
1647 _this3.refInput[0].setSelectionRange(start, end);
1648 _this3.refInput[0].focus();
1649 } else if (pos === 'max') {
1650 _this3.refInput[1].setSelectionRange(start, end);
1651 _this3.refInput[1].focus();
1652 }
1653 });
1654 },
1655 unmountPicker: function unmountPicker() {
1656 if (this.picker) {
1657 this.picker.$destroy();
1658 this.picker.$off();
1659 if (typeof this.unwatchPickerOptions === 'function') {
1660 this.unwatchPickerOptions();
1661 }
1662 this.picker.$el.parentNode.removeChild(this.picker.$el);
1663 }
1664 },
1665 emitChange: function emitChange(val) {
1666 // determine user real change only
1667 if (!valueEquals(val, this.valueOnOpen)) {
1668 this.$emit('change', val);
1669 this.valueOnOpen = val;
1670 if (this.validateEvent) {
1671 this.dispatch('ElFormItem', 'el.form.change', val);
1672 }
1673 }
1674 },
1675 emitInput: function emitInput(val) {
1676 var formatted = this.formatToValue(val);
1677 if (!valueEquals(this.value, formatted)) {
1678 this.$emit('input', formatted);
1679 }
1680 },
1681 isValidValue: function isValidValue(value) {
1682 if (!this.picker) {
1683 this.mountPicker();
1684 }
1685 if (this.picker.isValidValue) {
1686 return value && this.picker.isValidValue(value);
1687 } else {
1688 return true;
1689 }
1690 }
1691 }
1692});
1693// CONCATENATED MODULE: ./packages/date-picker/src/picker.vue?vue&type=script&lang=js&
1694 /* harmony default export */ var src_pickervue_type_script_lang_js_ = (pickervue_type_script_lang_js_);
1695// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
1696var componentNormalizer = __webpack_require__(0);
1697
1698// CONCATENATED MODULE: ./packages/date-picker/src/picker.vue
1699
1700
1701
1702
1703
1704/* normalize component */
1705
1706var component = Object(componentNormalizer["a" /* default */])(
1707 src_pickervue_type_script_lang_js_,
1708 render,
1709 staticRenderFns,
1710 false,
1711 null,
1712 null,
1713 null
1714
1715)
1716
1717/* hot reload */
1718if (false) { var api; }
1719component.options.__file = "packages/date-picker/src/picker.vue"
1720/* harmony default export */ var picker = __webpack_exports__["a"] = (component.exports);
1721
1722/***/ }),
1723
1724/***/ 35:
1725/***/ (function(module, __webpack_exports__, __webpack_require__) {
1726
1727"use strict";
1728
1729// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/basic/time-spinner.vue?vue&type=template&id=1facadeb&
1730var render = function() {
1731 var _vm = this
1732 var _h = _vm.$createElement
1733 var _c = _vm._self._c || _h
1734 return _c(
1735 "div",
1736 {
1737 staticClass: "el-time-spinner",
1738 class: { "has-seconds": _vm.showSeconds }
1739 },
1740 [
1741 !_vm.arrowControl
1742 ? [
1743 _c(
1744 "el-scrollbar",
1745 {
1746 ref: "hours",
1747 staticClass: "el-time-spinner__wrapper",
1748 attrs: {
1749 "wrap-style": "max-height: inherit;",
1750 "view-class": "el-time-spinner__list",
1751 noresize: "",
1752 tag: "ul"
1753 },
1754 nativeOn: {
1755 mouseenter: function($event) {
1756 _vm.emitSelectRange("hours")
1757 },
1758 mousemove: function($event) {
1759 _vm.adjustCurrentSpinner("hours")
1760 }
1761 }
1762 },
1763 _vm._l(_vm.hoursList, function(disabled, hour) {
1764 return _c(
1765 "li",
1766 {
1767 key: hour,
1768 staticClass: "el-time-spinner__item",
1769 class: { active: hour === _vm.hours, disabled: disabled },
1770 on: {
1771 click: function($event) {
1772 _vm.handleClick("hours", {
1773 value: hour,
1774 disabled: disabled
1775 })
1776 }
1777 }
1778 },
1779 [
1780 _vm._v(
1781 _vm._s(
1782 ("0" + (_vm.amPmMode ? hour % 12 || 12 : hour)).slice(
1783 -2
1784 )
1785 ) + _vm._s(_vm.amPm(hour))
1786 )
1787 ]
1788 )
1789 }),
1790 0
1791 ),
1792 _c(
1793 "el-scrollbar",
1794 {
1795 ref: "minutes",
1796 staticClass: "el-time-spinner__wrapper",
1797 attrs: {
1798 "wrap-style": "max-height: inherit;",
1799 "view-class": "el-time-spinner__list",
1800 noresize: "",
1801 tag: "ul"
1802 },
1803 nativeOn: {
1804 mouseenter: function($event) {
1805 _vm.emitSelectRange("minutes")
1806 },
1807 mousemove: function($event) {
1808 _vm.adjustCurrentSpinner("minutes")
1809 }
1810 }
1811 },
1812 _vm._l(_vm.minutesList, function(enabled, key) {
1813 return _c(
1814 "li",
1815 {
1816 key: key,
1817 staticClass: "el-time-spinner__item",
1818 class: { active: key === _vm.minutes, disabled: !enabled },
1819 on: {
1820 click: function($event) {
1821 _vm.handleClick("minutes", {
1822 value: key,
1823 disabled: false
1824 })
1825 }
1826 }
1827 },
1828 [_vm._v(_vm._s(("0" + key).slice(-2)))]
1829 )
1830 }),
1831 0
1832 ),
1833 _c(
1834 "el-scrollbar",
1835 {
1836 directives: [
1837 {
1838 name: "show",
1839 rawName: "v-show",
1840 value: _vm.showSeconds,
1841 expression: "showSeconds"
1842 }
1843 ],
1844 ref: "seconds",
1845 staticClass: "el-time-spinner__wrapper",
1846 attrs: {
1847 "wrap-style": "max-height: inherit;",
1848 "view-class": "el-time-spinner__list",
1849 noresize: "",
1850 tag: "ul"
1851 },
1852 nativeOn: {
1853 mouseenter: function($event) {
1854 _vm.emitSelectRange("seconds")
1855 },
1856 mousemove: function($event) {
1857 _vm.adjustCurrentSpinner("seconds")
1858 }
1859 }
1860 },
1861 _vm._l(60, function(second, key) {
1862 return _c(
1863 "li",
1864 {
1865 key: key,
1866 staticClass: "el-time-spinner__item",
1867 class: { active: key === _vm.seconds },
1868 on: {
1869 click: function($event) {
1870 _vm.handleClick("seconds", {
1871 value: key,
1872 disabled: false
1873 })
1874 }
1875 }
1876 },
1877 [_vm._v(_vm._s(("0" + key).slice(-2)))]
1878 )
1879 }),
1880 0
1881 )
1882 ]
1883 : _vm._e(),
1884 _vm.arrowControl
1885 ? [
1886 _c(
1887 "div",
1888 {
1889 staticClass: "el-time-spinner__wrapper is-arrow",
1890 on: {
1891 mouseenter: function($event) {
1892 _vm.emitSelectRange("hours")
1893 }
1894 }
1895 },
1896 [
1897 _c("i", {
1898 directives: [
1899 {
1900 name: "repeat-click",
1901 rawName: "v-repeat-click",
1902 value: _vm.decrease,
1903 expression: "decrease"
1904 }
1905 ],
1906 staticClass: "el-time-spinner__arrow el-icon-arrow-up"
1907 }),
1908 _c("i", {
1909 directives: [
1910 {
1911 name: "repeat-click",
1912 rawName: "v-repeat-click",
1913 value: _vm.increase,
1914 expression: "increase"
1915 }
1916 ],
1917 staticClass: "el-time-spinner__arrow el-icon-arrow-down"
1918 }),
1919 _c(
1920 "ul",
1921 { ref: "hours", staticClass: "el-time-spinner__list" },
1922 _vm._l(_vm.arrowHourList, function(hour, key) {
1923 return _c(
1924 "li",
1925 {
1926 key: key,
1927 staticClass: "el-time-spinner__item",
1928 class: {
1929 active: hour === _vm.hours,
1930 disabled: _vm.hoursList[hour]
1931 }
1932 },
1933 [
1934 _vm._v(
1935 _vm._s(
1936 hour === undefined
1937 ? ""
1938 : (
1939 "0" + (_vm.amPmMode ? hour % 12 || 12 : hour)
1940 ).slice(-2) + _vm.amPm(hour)
1941 )
1942 )
1943 ]
1944 )
1945 }),
1946 0
1947 )
1948 ]
1949 ),
1950 _c(
1951 "div",
1952 {
1953 staticClass: "el-time-spinner__wrapper is-arrow",
1954 on: {
1955 mouseenter: function($event) {
1956 _vm.emitSelectRange("minutes")
1957 }
1958 }
1959 },
1960 [
1961 _c("i", {
1962 directives: [
1963 {
1964 name: "repeat-click",
1965 rawName: "v-repeat-click",
1966 value: _vm.decrease,
1967 expression: "decrease"
1968 }
1969 ],
1970 staticClass: "el-time-spinner__arrow el-icon-arrow-up"
1971 }),
1972 _c("i", {
1973 directives: [
1974 {
1975 name: "repeat-click",
1976 rawName: "v-repeat-click",
1977 value: _vm.increase,
1978 expression: "increase"
1979 }
1980 ],
1981 staticClass: "el-time-spinner__arrow el-icon-arrow-down"
1982 }),
1983 _c(
1984 "ul",
1985 { ref: "minutes", staticClass: "el-time-spinner__list" },
1986 _vm._l(_vm.arrowMinuteList, function(minute, key) {
1987 return _c(
1988 "li",
1989 {
1990 key: key,
1991 staticClass: "el-time-spinner__item",
1992 class: { active: minute === _vm.minutes }
1993 },
1994 [
1995 _vm._v(
1996 "\n " +
1997 _vm._s(
1998 minute === undefined
1999 ? ""
2000 : ("0" + minute).slice(-2)
2001 ) +
2002 "\n "
2003 )
2004 ]
2005 )
2006 }),
2007 0
2008 )
2009 ]
2010 ),
2011 _vm.showSeconds
2012 ? _c(
2013 "div",
2014 {
2015 staticClass: "el-time-spinner__wrapper is-arrow",
2016 on: {
2017 mouseenter: function($event) {
2018 _vm.emitSelectRange("seconds")
2019 }
2020 }
2021 },
2022 [
2023 _c("i", {
2024 directives: [
2025 {
2026 name: "repeat-click",
2027 rawName: "v-repeat-click",
2028 value: _vm.decrease,
2029 expression: "decrease"
2030 }
2031 ],
2032 staticClass: "el-time-spinner__arrow el-icon-arrow-up"
2033 }),
2034 _c("i", {
2035 directives: [
2036 {
2037 name: "repeat-click",
2038 rawName: "v-repeat-click",
2039 value: _vm.increase,
2040 expression: "increase"
2041 }
2042 ],
2043 staticClass: "el-time-spinner__arrow el-icon-arrow-down"
2044 }),
2045 _c(
2046 "ul",
2047 { ref: "seconds", staticClass: "el-time-spinner__list" },
2048 _vm._l(_vm.arrowSecondList, function(second, key) {
2049 return _c(
2050 "li",
2051 {
2052 key: key,
2053 staticClass: "el-time-spinner__item",
2054 class: { active: second === _vm.seconds }
2055 },
2056 [
2057 _vm._v(
2058 "\n " +
2059 _vm._s(
2060 second === undefined
2061 ? ""
2062 : ("0" + second).slice(-2)
2063 ) +
2064 "\n "
2065 )
2066 ]
2067 )
2068 }),
2069 0
2070 )
2071 ]
2072 )
2073 : _vm._e()
2074 ]
2075 : _vm._e()
2076 ],
2077 2
2078 )
2079}
2080var staticRenderFns = []
2081render._withStripped = true
2082
2083
2084// CONCATENATED MODULE: ./packages/date-picker/src/basic/time-spinner.vue?vue&type=template&id=1facadeb&
2085
2086// EXTERNAL MODULE: external "element-ui/lib/utils/date-util"
2087var date_util_ = __webpack_require__(1);
2088
2089// EXTERNAL MODULE: external "element-ui/lib/scrollbar"
2090var scrollbar_ = __webpack_require__(14);
2091var scrollbar_default = /*#__PURE__*/__webpack_require__.n(scrollbar_);
2092
2093// EXTERNAL MODULE: ./src/directives/repeat-click.js
2094var repeat_click = __webpack_require__(30);
2095
2096// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/basic/time-spinner.vue?vue&type=script&lang=js&
2097//
2098//
2099//
2100//
2101//
2102//
2103//
2104//
2105//
2106//
2107//
2108//
2109//
2110//
2111//
2112//
2113//
2114//
2115//
2116//
2117//
2118//
2119//
2120//
2121//
2122//
2123//
2124//
2125//
2126//
2127//
2128//
2129//
2130//
2131//
2132//
2133//
2134//
2135//
2136//
2137//
2138//
2139//
2140//
2141//
2142//
2143//
2144//
2145//
2146//
2147//
2148//
2149//
2150//
2151//
2152//
2153//
2154//
2155//
2156//
2157//
2158//
2159//
2160//
2161//
2162//
2163//
2164//
2165//
2166//
2167//
2168//
2169//
2170//
2171//
2172//
2173//
2174//
2175//
2176//
2177//
2178//
2179//
2180//
2181//
2182//
2183//
2184//
2185//
2186//
2187//
2188//
2189//
2190//
2191//
2192//
2193//
2194//
2195//
2196//
2197//
2198//
2199
2200
2201
2202
2203
2204/* harmony default export */ var time_spinnervue_type_script_lang_js_ = ({
2205 components: { ElScrollbar: scrollbar_default.a },
2206
2207 directives: {
2208 repeatClick: repeat_click["a" /* default */]
2209 },
2210
2211 props: {
2212 date: {},
2213 defaultValue: {}, // reserved for future use
2214 showSeconds: {
2215 type: Boolean,
2216 default: true
2217 },
2218 arrowControl: Boolean,
2219 amPmMode: {
2220 type: String,
2221 default: '' // 'a': am/pm; 'A': AM/PM
2222 }
2223 },
2224
2225 computed: {
2226 hours: function hours() {
2227 return this.date.getHours();
2228 },
2229 minutes: function minutes() {
2230 return this.date.getMinutes();
2231 },
2232 seconds: function seconds() {
2233 return this.date.getSeconds();
2234 },
2235 hoursList: function hoursList() {
2236 return Object(date_util_["getRangeHours"])(this.selectableRange);
2237 },
2238 minutesList: function minutesList() {
2239 return Object(date_util_["getRangeMinutes"])(this.selectableRange, this.hours);
2240 },
2241 arrowHourList: function arrowHourList() {
2242 var hours = this.hours;
2243 return [hours > 0 ? hours - 1 : undefined, hours, hours < 23 ? hours + 1 : undefined];
2244 },
2245 arrowMinuteList: function arrowMinuteList() {
2246 var minutes = this.minutes;
2247 return [minutes > 0 ? minutes - 1 : undefined, minutes, minutes < 59 ? minutes + 1 : undefined];
2248 },
2249 arrowSecondList: function arrowSecondList() {
2250 var seconds = this.seconds;
2251 return [seconds > 0 ? seconds - 1 : undefined, seconds, seconds < 59 ? seconds + 1 : undefined];
2252 }
2253 },
2254
2255 data: function data() {
2256 return {
2257 selectableRange: [],
2258 currentScrollbar: null
2259 };
2260 },
2261 mounted: function mounted() {
2262 var _this = this;
2263
2264 this.$nextTick(function () {
2265 !_this.arrowControl && _this.bindScrollEvent();
2266 });
2267 },
2268
2269
2270 methods: {
2271 increase: function increase() {
2272 this.scrollDown(1);
2273 },
2274 decrease: function decrease() {
2275 this.scrollDown(-1);
2276 },
2277 modifyDateField: function modifyDateField(type, value) {
2278 switch (type) {
2279 case 'hours':
2280 this.$emit('change', Object(date_util_["modifyTime"])(this.date, value, this.minutes, this.seconds));break;
2281 case 'minutes':
2282 this.$emit('change', Object(date_util_["modifyTime"])(this.date, this.hours, value, this.seconds));break;
2283 case 'seconds':
2284 this.$emit('change', Object(date_util_["modifyTime"])(this.date, this.hours, this.minutes, value));break;
2285 }
2286 },
2287 handleClick: function handleClick(type, _ref) {
2288 var value = _ref.value,
2289 disabled = _ref.disabled;
2290
2291 if (!disabled) {
2292 this.modifyDateField(type, value);
2293 this.emitSelectRange(type);
2294 this.adjustSpinner(type, value);
2295 }
2296 },
2297 emitSelectRange: function emitSelectRange(type) {
2298 if (type === 'hours') {
2299 this.$emit('select-range', 0, 2);
2300 } else if (type === 'minutes') {
2301 this.$emit('select-range', 3, 5);
2302 } else if (type === 'seconds') {
2303 this.$emit('select-range', 6, 8);
2304 }
2305 this.currentScrollbar = type;
2306 },
2307 bindScrollEvent: function bindScrollEvent() {
2308 var _this2 = this;
2309
2310 var bindFuntion = function bindFuntion(type) {
2311 _this2.$refs[type].wrap.onscroll = function (e) {
2312 // TODO: scroll is emitted when set scrollTop programatically
2313 // should find better solutions in the future!
2314 _this2.handleScroll(type, e);
2315 };
2316 };
2317 bindFuntion('hours');
2318 bindFuntion('minutes');
2319 bindFuntion('seconds');
2320 },
2321 handleScroll: function handleScroll(type) {
2322 var value = Math.min(Math.round((this.$refs[type].wrap.scrollTop - (this.scrollBarHeight(type) * 0.5 - 10) / this.typeItemHeight(type) + 3) / this.typeItemHeight(type)), type === 'hours' ? 23 : 59);
2323 this.modifyDateField(type, value);
2324 },
2325
2326
2327 // NOTE: used by datetime / date-range panel
2328 // renamed from adjustScrollTop
2329 // should try to refactory it
2330 adjustSpinners: function adjustSpinners() {
2331 this.adjustSpinner('hours', this.hours);
2332 this.adjustSpinner('minutes', this.minutes);
2333 this.adjustSpinner('seconds', this.seconds);
2334 },
2335 adjustCurrentSpinner: function adjustCurrentSpinner(type) {
2336 this.adjustSpinner(type, this[type]);
2337 },
2338 adjustSpinner: function adjustSpinner(type, value) {
2339 if (this.arrowControl) return;
2340 var el = this.$refs[type].wrap;
2341 if (el) {
2342 el.scrollTop = Math.max(0, value * this.typeItemHeight(type));
2343 }
2344 },
2345 scrollDown: function scrollDown(step) {
2346 var _this3 = this;
2347
2348 if (!this.currentScrollbar) {
2349 this.emitSelectRange('hours');
2350 }
2351
2352 var label = this.currentScrollbar;
2353 var hoursList = this.hoursList;
2354 var now = this[label];
2355
2356 if (this.currentScrollbar === 'hours') {
2357 var total = Math.abs(step);
2358 step = step > 0 ? 1 : -1;
2359 var length = hoursList.length;
2360 while (length-- && total) {
2361 now = (now + step + hoursList.length) % hoursList.length;
2362 if (hoursList[now]) {
2363 continue;
2364 }
2365 total--;
2366 }
2367 if (hoursList[now]) return;
2368 } else {
2369 now = (now + step + 60) % 60;
2370 }
2371
2372 this.modifyDateField(label, now);
2373 this.adjustSpinner(label, now);
2374 this.$nextTick(function () {
2375 return _this3.emitSelectRange(_this3.currentScrollbar);
2376 });
2377 },
2378 amPm: function amPm(hour) {
2379 var shouldShowAmPm = this.amPmMode.toLowerCase() === 'a';
2380 if (!shouldShowAmPm) return '';
2381 var isCapital = this.amPmMode === 'A';
2382 var content = hour < 12 ? ' am' : ' pm';
2383 if (isCapital) content = content.toUpperCase();
2384 return content;
2385 },
2386 typeItemHeight: function typeItemHeight(type) {
2387 return this.$refs[type].$el.querySelector('li').offsetHeight;
2388 },
2389 scrollBarHeight: function scrollBarHeight(type) {
2390 return this.$refs[type].$el.offsetHeight;
2391 }
2392 }
2393});
2394// CONCATENATED MODULE: ./packages/date-picker/src/basic/time-spinner.vue?vue&type=script&lang=js&
2395 /* harmony default export */ var basic_time_spinnervue_type_script_lang_js_ = (time_spinnervue_type_script_lang_js_);
2396// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
2397var componentNormalizer = __webpack_require__(0);
2398
2399// CONCATENATED MODULE: ./packages/date-picker/src/basic/time-spinner.vue
2400
2401
2402
2403
2404
2405/* normalize component */
2406
2407var component = Object(componentNormalizer["a" /* default */])(
2408 basic_time_spinnervue_type_script_lang_js_,
2409 render,
2410 staticRenderFns,
2411 false,
2412 null,
2413 null,
2414 null
2415
2416)
2417
2418/* hot reload */
2419if (false) { var api; }
2420component.options.__file = "packages/date-picker/src/basic/time-spinner.vue"
2421/* harmony default export */ var time_spinner = __webpack_exports__["a"] = (component.exports);
2422
2423/***/ }),
2424
2425/***/ 4:
2426/***/ (function(module, exports) {
2427
2428module.exports = require("element-ui/lib/mixins/emitter");
2429
2430/***/ }),
2431
2432/***/ 5:
2433/***/ (function(module, exports) {
2434
2435module.exports = require("element-ui/lib/utils/vue-popper");
2436
2437/***/ }),
2438
2439/***/ 6:
2440/***/ (function(module, exports) {
2441
2442module.exports = require("element-ui/lib/mixins/locale");
2443
2444/***/ }),
2445
2446/***/ 7:
2447/***/ (function(module, exports) {
2448
2449module.exports = require("vue");
2450
2451/***/ }),
2452
2453/***/ 71:
2454/***/ (function(module, __webpack_exports__, __webpack_require__) {
2455
2456"use strict";
2457__webpack_require__.r(__webpack_exports__);
2458
2459// EXTERNAL MODULE: ./packages/date-picker/src/picker.vue + 4 modules
2460var picker = __webpack_require__(33);
2461
2462// EXTERNAL MODULE: ./packages/date-picker/src/panel/time.vue + 4 modules
2463var time = __webpack_require__(27);
2464
2465// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/panel/time-range.vue?vue&type=template&id=fb28660e&
2466var render = function() {
2467 var _vm = this
2468 var _h = _vm.$createElement
2469 var _c = _vm._self._c || _h
2470 return _c(
2471 "transition",
2472 {
2473 attrs: { name: "el-zoom-in-top" },
2474 on: {
2475 "after-leave": function($event) {
2476 _vm.$emit("dodestroy")
2477 }
2478 }
2479 },
2480 [
2481 _c(
2482 "div",
2483 {
2484 directives: [
2485 {
2486 name: "show",
2487 rawName: "v-show",
2488 value: _vm.visible,
2489 expression: "visible"
2490 }
2491 ],
2492 staticClass: "el-time-range-picker el-picker-panel el-popper",
2493 class: _vm.popperClass
2494 },
2495 [
2496 _c("div", { staticClass: "el-time-range-picker__content" }, [
2497 _c("div", { staticClass: "el-time-range-picker__cell" }, [
2498 _c("div", { staticClass: "el-time-range-picker__header" }, [
2499 _vm._v(_vm._s(_vm.t("el.datepicker.startTime")))
2500 ]),
2501 _c(
2502 "div",
2503 {
2504 staticClass:
2505 "el-time-range-picker__body el-time-panel__content",
2506 class: {
2507 "has-seconds": _vm.showSeconds,
2508 "is-arrow": _vm.arrowControl
2509 }
2510 },
2511 [
2512 _c("time-spinner", {
2513 ref: "minSpinner",
2514 attrs: {
2515 "show-seconds": _vm.showSeconds,
2516 "am-pm-mode": _vm.amPmMode,
2517 "arrow-control": _vm.arrowControl,
2518 date: _vm.minDate
2519 },
2520 on: {
2521 change: _vm.handleMinChange,
2522 "select-range": _vm.setMinSelectionRange
2523 }
2524 })
2525 ],
2526 1
2527 )
2528 ]),
2529 _c("div", { staticClass: "el-time-range-picker__cell" }, [
2530 _c("div", { staticClass: "el-time-range-picker__header" }, [
2531 _vm._v(_vm._s(_vm.t("el.datepicker.endTime")))
2532 ]),
2533 _c(
2534 "div",
2535 {
2536 staticClass:
2537 "el-time-range-picker__body el-time-panel__content",
2538 class: {
2539 "has-seconds": _vm.showSeconds,
2540 "is-arrow": _vm.arrowControl
2541 }
2542 },
2543 [
2544 _c("time-spinner", {
2545 ref: "maxSpinner",
2546 attrs: {
2547 "show-seconds": _vm.showSeconds,
2548 "am-pm-mode": _vm.amPmMode,
2549 "arrow-control": _vm.arrowControl,
2550 date: _vm.maxDate
2551 },
2552 on: {
2553 change: _vm.handleMaxChange,
2554 "select-range": _vm.setMaxSelectionRange
2555 }
2556 })
2557 ],
2558 1
2559 )
2560 ])
2561 ]),
2562 _c("div", { staticClass: "el-time-panel__footer" }, [
2563 _c(
2564 "button",
2565 {
2566 staticClass: "el-time-panel__btn cancel",
2567 attrs: { type: "button" },
2568 on: {
2569 click: function($event) {
2570 _vm.handleCancel()
2571 }
2572 }
2573 },
2574 [_vm._v(_vm._s(_vm.t("el.datepicker.cancel")))]
2575 ),
2576 _c(
2577 "button",
2578 {
2579 staticClass: "el-time-panel__btn confirm",
2580 attrs: { type: "button", disabled: _vm.btnDisabled },
2581 on: {
2582 click: function($event) {
2583 _vm.handleConfirm()
2584 }
2585 }
2586 },
2587 [_vm._v(_vm._s(_vm.t("el.datepicker.confirm")))]
2588 )
2589 ])
2590 ]
2591 )
2592 ]
2593 )
2594}
2595var staticRenderFns = []
2596render._withStripped = true
2597
2598
2599// CONCATENATED MODULE: ./packages/date-picker/src/panel/time-range.vue?vue&type=template&id=fb28660e&
2600
2601// EXTERNAL MODULE: external "element-ui/lib/utils/date-util"
2602var date_util_ = __webpack_require__(1);
2603
2604// EXTERNAL MODULE: external "element-ui/lib/mixins/locale"
2605var locale_ = __webpack_require__(6);
2606var locale_default = /*#__PURE__*/__webpack_require__.n(locale_);
2607
2608// EXTERNAL MODULE: ./packages/date-picker/src/basic/time-spinner.vue + 4 modules
2609var time_spinner = __webpack_require__(35);
2610
2611// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/date-picker/src/panel/time-range.vue?vue&type=script&lang=js&
2612//
2613//
2614//
2615//
2616//
2617//
2618//
2619//
2620//
2621//
2622//
2623//
2624//
2625//
2626//
2627//
2628//
2629//
2630//
2631//
2632//
2633//
2634//
2635//
2636//
2637//
2638//
2639//
2640//
2641//
2642//
2643//
2644//
2645//
2646//
2647//
2648//
2649//
2650//
2651//
2652//
2653//
2654//
2655//
2656//
2657//
2658//
2659//
2660//
2661//
2662//
2663//
2664//
2665//
2666//
2667//
2668//
2669
2670
2671
2672
2673
2674var MIN_TIME = Object(date_util_["parseDate"])('00:00:00', 'HH:mm:ss');
2675var MAX_TIME = Object(date_util_["parseDate"])('23:59:59', 'HH:mm:ss');
2676
2677var time_rangevue_type_script_lang_js_minTimeOfDay = function minTimeOfDay(date) {
2678 return Object(date_util_["modifyDate"])(MIN_TIME, date.getFullYear(), date.getMonth(), date.getDate());
2679};
2680
2681var time_rangevue_type_script_lang_js_maxTimeOfDay = function maxTimeOfDay(date) {
2682 return Object(date_util_["modifyDate"])(MAX_TIME, date.getFullYear(), date.getMonth(), date.getDate());
2683};
2684
2685// increase time by amount of milliseconds, but within the range of day
2686var advanceTime = function advanceTime(date, amount) {
2687 return new Date(Math.min(date.getTime() + amount, time_rangevue_type_script_lang_js_maxTimeOfDay(date).getTime()));
2688};
2689
2690/* harmony default export */ var time_rangevue_type_script_lang_js_ = ({
2691 mixins: [locale_default.a],
2692
2693 components: { TimeSpinner: time_spinner["a" /* default */] },
2694
2695 computed: {
2696 showSeconds: function showSeconds() {
2697 return (this.format || '').indexOf('ss') !== -1;
2698 },
2699 offset: function offset() {
2700 return this.showSeconds ? 11 : 8;
2701 },
2702 spinner: function spinner() {
2703 return this.selectionRange[0] < this.offset ? this.$refs.minSpinner : this.$refs.maxSpinner;
2704 },
2705 btnDisabled: function btnDisabled() {
2706 return this.minDate.getTime() > this.maxDate.getTime();
2707 },
2708 amPmMode: function amPmMode() {
2709 if ((this.format || '').indexOf('A') !== -1) return 'A';
2710 if ((this.format || '').indexOf('a') !== -1) return 'a';
2711 return '';
2712 }
2713 },
2714
2715 data: function data() {
2716 return {
2717 popperClass: '',
2718 minDate: new Date(),
2719 maxDate: new Date(),
2720 value: [],
2721 oldValue: [new Date(), new Date()],
2722 defaultValue: null,
2723 format: 'HH:mm:ss',
2724 visible: false,
2725 selectionRange: [0, 2],
2726 arrowControl: false
2727 };
2728 },
2729
2730
2731 watch: {
2732 value: function value(_value) {
2733 if (Array.isArray(_value)) {
2734 this.minDate = new Date(_value[0]);
2735 this.maxDate = new Date(_value[1]);
2736 } else {
2737 if (Array.isArray(this.defaultValue)) {
2738 this.minDate = new Date(this.defaultValue[0]);
2739 this.maxDate = new Date(this.defaultValue[1]);
2740 } else if (this.defaultValue) {
2741 this.minDate = new Date(this.defaultValue);
2742 this.maxDate = advanceTime(new Date(this.defaultValue), 60 * 60 * 1000);
2743 } else {
2744 this.minDate = new Date();
2745 this.maxDate = advanceTime(new Date(), 60 * 60 * 1000);
2746 }
2747 }
2748 },
2749 visible: function visible(val) {
2750 var _this = this;
2751
2752 if (val) {
2753 this.oldValue = this.value;
2754 this.$nextTick(function () {
2755 return _this.$refs.minSpinner.emitSelectRange('hours');
2756 });
2757 }
2758 }
2759 },
2760
2761 methods: {
2762 handleClear: function handleClear() {
2763 this.$emit('pick', null);
2764 },
2765 handleCancel: function handleCancel() {
2766 this.$emit('pick', this.oldValue);
2767 },
2768 handleMinChange: function handleMinChange(date) {
2769 this.minDate = Object(date_util_["clearMilliseconds"])(date);
2770 this.handleChange();
2771 },
2772 handleMaxChange: function handleMaxChange(date) {
2773 this.maxDate = Object(date_util_["clearMilliseconds"])(date);
2774 this.handleChange();
2775 },
2776 handleChange: function handleChange() {
2777 if (this.isValidValue([this.minDate, this.maxDate])) {
2778 this.$refs.minSpinner.selectableRange = [[time_rangevue_type_script_lang_js_minTimeOfDay(this.minDate), this.maxDate]];
2779 this.$refs.maxSpinner.selectableRange = [[this.minDate, time_rangevue_type_script_lang_js_maxTimeOfDay(this.maxDate)]];
2780 this.$emit('pick', [this.minDate, this.maxDate], true);
2781 }
2782 },
2783 setMinSelectionRange: function setMinSelectionRange(start, end) {
2784 this.$emit('select-range', start, end, 'min');
2785 this.selectionRange = [start, end];
2786 },
2787 setMaxSelectionRange: function setMaxSelectionRange(start, end) {
2788 this.$emit('select-range', start, end, 'max');
2789 this.selectionRange = [start + this.offset, end + this.offset];
2790 },
2791 handleConfirm: function handleConfirm() {
2792 var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
2793
2794 var minSelectableRange = this.$refs.minSpinner.selectableRange;
2795 var maxSelectableRange = this.$refs.maxSpinner.selectableRange;
2796
2797 this.minDate = Object(date_util_["limitTimeRange"])(this.minDate, minSelectableRange, this.format);
2798 this.maxDate = Object(date_util_["limitTimeRange"])(this.maxDate, maxSelectableRange, this.format);
2799
2800 this.$emit('pick', [this.minDate, this.maxDate], visible);
2801 },
2802 adjustSpinners: function adjustSpinners() {
2803 this.$refs.minSpinner.adjustSpinners();
2804 this.$refs.maxSpinner.adjustSpinners();
2805 },
2806 changeSelectionRange: function changeSelectionRange(step) {
2807 var list = this.showSeconds ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
2808 var mapping = ['hours', 'minutes'].concat(this.showSeconds ? ['seconds'] : []);
2809 var index = list.indexOf(this.selectionRange[0]);
2810 var next = (index + step + list.length) % list.length;
2811 var half = list.length / 2;
2812 if (next < half) {
2813 this.$refs.minSpinner.emitSelectRange(mapping[next]);
2814 } else {
2815 this.$refs.maxSpinner.emitSelectRange(mapping[next - half]);
2816 }
2817 },
2818 isValidValue: function isValidValue(date) {
2819 return Array.isArray(date) && Object(date_util_["timeWithinRange"])(this.minDate, this.$refs.minSpinner.selectableRange) && Object(date_util_["timeWithinRange"])(this.maxDate, this.$refs.maxSpinner.selectableRange);
2820 },
2821 handleKeydown: function handleKeydown(event) {
2822 var keyCode = event.keyCode;
2823 var mapping = { 38: -1, 40: 1, 37: -1, 39: 1 };
2824
2825 // Left or Right
2826 if (keyCode === 37 || keyCode === 39) {
2827 var step = mapping[keyCode];
2828 this.changeSelectionRange(step);
2829 event.preventDefault();
2830 return;
2831 }
2832
2833 // Up or Down
2834 if (keyCode === 38 || keyCode === 40) {
2835 var _step = mapping[keyCode];
2836 this.spinner.scrollDown(_step);
2837 event.preventDefault();
2838 return;
2839 }
2840 }
2841 }
2842});
2843// CONCATENATED MODULE: ./packages/date-picker/src/panel/time-range.vue?vue&type=script&lang=js&
2844 /* harmony default export */ var panel_time_rangevue_type_script_lang_js_ = (time_rangevue_type_script_lang_js_);
2845// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
2846var componentNormalizer = __webpack_require__(0);
2847
2848// CONCATENATED MODULE: ./packages/date-picker/src/panel/time-range.vue
2849
2850
2851
2852
2853
2854/* normalize component */
2855
2856var component = Object(componentNormalizer["a" /* default */])(
2857 panel_time_rangevue_type_script_lang_js_,
2858 render,
2859 staticRenderFns,
2860 false,
2861 null,
2862 null,
2863 null
2864
2865)
2866
2867/* hot reload */
2868if (false) { var api; }
2869component.options.__file = "packages/date-picker/src/panel/time-range.vue"
2870/* harmony default export */ var time_range = (component.exports);
2871// CONCATENATED MODULE: ./packages/date-picker/src/picker/time-picker.js
2872
2873
2874
2875
2876/* harmony default export */ var time_picker = ({
2877 mixins: [picker["a" /* default */]],
2878
2879 name: 'ElTimePicker',
2880
2881 props: {
2882 isRange: Boolean,
2883 arrowControl: Boolean
2884 },
2885
2886 data: function data() {
2887 return {
2888 type: ''
2889 };
2890 },
2891
2892
2893 watch: {
2894 isRange: function isRange(_isRange) {
2895 if (this.picker) {
2896 this.unmountPicker();
2897 this.type = _isRange ? 'timerange' : 'time';
2898 this.panel = _isRange ? time_range : time["a" /* default */];
2899 this.mountPicker();
2900 } else {
2901 this.type = _isRange ? 'timerange' : 'time';
2902 this.panel = _isRange ? time_range : time["a" /* default */];
2903 }
2904 }
2905 },
2906
2907 created: function created() {
2908 this.type = this.isRange ? 'timerange' : 'time';
2909 this.panel = this.isRange ? time_range : time["a" /* default */];
2910 }
2911});
2912// CONCATENATED MODULE: ./packages/time-picker/index.js
2913
2914
2915/* istanbul ignore next */
2916time_picker.install = function (Vue) {
2917 Vue.component(time_picker.name, time_picker);
2918};
2919
2920/* harmony default export */ var packages_time_picker = __webpack_exports__["default"] = (time_picker);
2921
2922/***/ }),
2923
2924/***/ 9:
2925/***/ (function(module, exports) {
2926
2927module.exports = require("element-ui/lib/utils/merge");
2928
2929/***/ })
2930
2931/******/ });
\No newline at end of file