mirror of
https://github.com/mindoc-org/mindoc.git
synced 2025-05-06 22:57:57 +08:00
1921 lines
46 KiB
JavaScript
1921 lines
46 KiB
JavaScript
module.exports =
|
|
/******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId])
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
|
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "/dist/";
|
|
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ({
|
|
|
|
/***/ 0:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(330);
|
|
|
|
|
|
/***/ },
|
|
|
|
/***/ 3:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = function normalizeComponent (
|
|
rawScriptExports,
|
|
compiledTemplate,
|
|
scopeId,
|
|
cssModules
|
|
) {
|
|
var esModule
|
|
var scriptExports = rawScriptExports = rawScriptExports || {}
|
|
|
|
// ES6 modules interop
|
|
var type = typeof rawScriptExports.default
|
|
if (type === 'object' || type === 'function') {
|
|
esModule = rawScriptExports
|
|
scriptExports = rawScriptExports.default
|
|
}
|
|
|
|
// Vue.extend constructor export interop
|
|
var options = typeof scriptExports === 'function'
|
|
? scriptExports.options
|
|
: scriptExports
|
|
|
|
// render functions
|
|
if (compiledTemplate) {
|
|
options.render = compiledTemplate.render
|
|
options.staticRenderFns = compiledTemplate.staticRenderFns
|
|
}
|
|
|
|
// scopedId
|
|
if (scopeId) {
|
|
options._scopeId = scopeId
|
|
}
|
|
|
|
// inject cssModules
|
|
if (cssModules) {
|
|
var computed = options.computed || (options.computed = {})
|
|
Object.keys(cssModules).forEach(function (key) {
|
|
var module = cssModules[key]
|
|
computed[key] = function () { return module }
|
|
})
|
|
}
|
|
|
|
return {
|
|
esModule: esModule,
|
|
exports: scriptExports,
|
|
options: options
|
|
}
|
|
}
|
|
|
|
|
|
/***/ },
|
|
|
|
/***/ 9:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/input");
|
|
|
|
/***/ },
|
|
|
|
/***/ 10:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/utils/clickoutside");
|
|
|
|
/***/ },
|
|
|
|
/***/ 13:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/utils/vue-popper");
|
|
|
|
/***/ },
|
|
|
|
/***/ 14:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/mixins/emitter");
|
|
|
|
/***/ },
|
|
|
|
/***/ 15:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/scrollbar");
|
|
|
|
/***/ },
|
|
|
|
/***/ 56:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("vue");
|
|
|
|
/***/ },
|
|
|
|
/***/ 60:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/mixins/locale");
|
|
|
|
/***/ },
|
|
|
|
/***/ 102:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(103),
|
|
/* template */
|
|
__webpack_require__(106),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ },
|
|
|
|
/***/ 103:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _vue = __webpack_require__(56);
|
|
|
|
var _vue2 = _interopRequireDefault(_vue);
|
|
|
|
var _clickoutside = __webpack_require__(10);
|
|
|
|
var _clickoutside2 = _interopRequireDefault(_clickoutside);
|
|
|
|
var _util = __webpack_require__(104);
|
|
|
|
var _vuePopper = __webpack_require__(13);
|
|
|
|
var _vuePopper2 = _interopRequireDefault(_vuePopper);
|
|
|
|
var _emitter = __webpack_require__(14);
|
|
|
|
var _emitter2 = _interopRequireDefault(_emitter);
|
|
|
|
var _input = __webpack_require__(9);
|
|
|
|
var _input2 = _interopRequireDefault(_input);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
var NewPopper = {
|
|
props: {
|
|
appendToBody: _vuePopper2.default.props.appendToBody,
|
|
offset: _vuePopper2.default.props.offset,
|
|
boundariesPadding: _vuePopper2.default.props.boundariesPadding
|
|
},
|
|
methods: _vuePopper2.default.methods,
|
|
data: _vuePopper2.default.data,
|
|
beforeDestroy: _vuePopper2.default.beforeDestroy
|
|
};
|
|
|
|
var DEFAULT_FORMATS = {
|
|
date: 'yyyy-MM-dd',
|
|
month: 'yyyy-MM',
|
|
datetime: 'yyyy-MM-dd HH:mm:ss',
|
|
time: 'HH:mm:ss',
|
|
week: 'yyyywWW',
|
|
timerange: 'HH:mm:ss',
|
|
daterange: 'yyyy-MM-dd',
|
|
datetimerange: 'yyyy-MM-dd HH:mm:ss',
|
|
year: 'yyyy'
|
|
};
|
|
var HAVE_TRIGGER_TYPES = ['date', 'datetime', 'time', 'time-select', 'week', 'month', 'year', 'daterange', 'timerange', 'datetimerange'];
|
|
var DATE_FORMATTER = function DATE_FORMATTER(value, format) {
|
|
return (0, _util.formatDate)(value, format);
|
|
};
|
|
var DATE_PARSER = function DATE_PARSER(text, format) {
|
|
return (0, _util.parseDate)(text, format);
|
|
};
|
|
var RANGE_FORMATTER = function RANGE_FORMATTER(value, format, separator) {
|
|
if (Array.isArray(value) && value.length === 2) {
|
|
var start = value[0];
|
|
var end = value[1];
|
|
|
|
if (start && end) {
|
|
return (0, _util.formatDate)(start, format) + separator + (0, _util.formatDate)(end, format);
|
|
}
|
|
}
|
|
return '';
|
|
};
|
|
var RANGE_PARSER = function RANGE_PARSER(text, format, separator) {
|
|
var array = text.split(separator);
|
|
if (array.length === 2) {
|
|
var range1 = array[0];
|
|
var range2 = array[1];
|
|
|
|
return [(0, _util.parseDate)(range1, format), (0, _util.parseDate)(range2, format)];
|
|
}
|
|
return [];
|
|
};
|
|
var TYPE_VALUE_RESOLVER_MAP = {
|
|
default: {
|
|
formatter: function formatter(value) {
|
|
if (!value) return '';
|
|
return '' + value;
|
|
},
|
|
parser: function parser(text) {
|
|
if (text === undefined || text === '') return null;
|
|
return text;
|
|
}
|
|
},
|
|
week: {
|
|
formatter: function formatter(value, format) {
|
|
var date = (0, _util.formatDate)(value, format);
|
|
var week = (0, _util.getWeekNumber)(value);
|
|
|
|
date = /WW/.test(date) ? date.replace(/WW/, week < 10 ? '0' + week : week) : date.replace(/W/, week);
|
|
return date;
|
|
},
|
|
parser: function parser(text) {
|
|
var array = (text || '').split('w');
|
|
if (array.length === 2) {
|
|
var year = Number(array[0]);
|
|
var month = Number(array[1]);
|
|
|
|
if (!isNaN(year) && !isNaN(month) && month < 54) {
|
|
return text;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
},
|
|
date: {
|
|
formatter: DATE_FORMATTER,
|
|
parser: DATE_PARSER
|
|
},
|
|
datetime: {
|
|
formatter: DATE_FORMATTER,
|
|
parser: DATE_PARSER
|
|
},
|
|
daterange: {
|
|
formatter: RANGE_FORMATTER,
|
|
parser: RANGE_PARSER
|
|
},
|
|
datetimerange: {
|
|
formatter: RANGE_FORMATTER,
|
|
parser: RANGE_PARSER
|
|
},
|
|
timerange: {
|
|
formatter: RANGE_FORMATTER,
|
|
parser: RANGE_PARSER
|
|
},
|
|
time: {
|
|
formatter: DATE_FORMATTER,
|
|
parser: DATE_PARSER
|
|
},
|
|
month: {
|
|
formatter: DATE_FORMATTER,
|
|
parser: DATE_PARSER
|
|
},
|
|
year: {
|
|
formatter: DATE_FORMATTER,
|
|
parser: DATE_PARSER
|
|
},
|
|
number: {
|
|
formatter: function formatter(value) {
|
|
if (!value) return '';
|
|
return '' + value;
|
|
},
|
|
parser: function parser(text) {
|
|
var result = Number(text);
|
|
|
|
if (!isNaN(text)) {
|
|
return result;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PLACEMENT_MAP = {
|
|
left: 'bottom-start',
|
|
center: 'bottom-center',
|
|
right: 'bottom-end'
|
|
};
|
|
|
|
exports.default = {
|
|
mixins: [_emitter2.default, NewPopper],
|
|
|
|
props: {
|
|
size: String,
|
|
format: String,
|
|
readonly: Boolean,
|
|
placeholder: String,
|
|
disabled: Boolean,
|
|
clearable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
popperClass: String,
|
|
editable: {
|
|
type: Boolean,
|
|
default: true
|
|
},
|
|
align: {
|
|
type: String,
|
|
default: 'left'
|
|
},
|
|
value: {},
|
|
rangeSeparator: {
|
|
default: ' - '
|
|
},
|
|
pickerOptions: {}
|
|
},
|
|
|
|
components: { ElInput: _input2.default },
|
|
|
|
directives: { Clickoutside: _clickoutside2.default },
|
|
|
|
data: function data() {
|
|
return {
|
|
pickerVisible: false,
|
|
showClose: false,
|
|
currentValue: ''
|
|
};
|
|
},
|
|
|
|
|
|
watch: {
|
|
pickerVisible: function pickerVisible(val) {
|
|
if (!val) this.dispatch('ElFormItem', 'el.form.blur');
|
|
if (this.readonly || this.disabled) return;
|
|
val ? this.showPicker() : this.hidePicker();
|
|
},
|
|
currentValue: function currentValue(val) {
|
|
if (val) return;
|
|
if (this.picker && typeof this.picker.handleClear === 'function') {
|
|
this.picker.handleClear();
|
|
} else {
|
|
this.$emit('input');
|
|
}
|
|
},
|
|
|
|
value: {
|
|
immediate: true,
|
|
handler: function handler(val) {
|
|
this.currentValue = (0, _util.isDate)(val) ? new Date(val) : val;
|
|
}
|
|
},
|
|
displayValue: function displayValue(val) {
|
|
this.$emit('change', val);
|
|
this.dispatch('ElFormItem', 'el.form.change');
|
|
}
|
|
},
|
|
|
|
computed: {
|
|
reference: function reference() {
|
|
return this.$refs.reference.$el;
|
|
},
|
|
refInput: function refInput() {
|
|
if (this.reference) return this.reference.querySelector('input');
|
|
return {};
|
|
},
|
|
valueIsEmpty: function valueIsEmpty() {
|
|
var val = this.currentValue;
|
|
if (Array.isArray(val)) {
|
|
for (var i = 0, len = val.length; i < len; i++) {
|
|
if (val[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
if (val) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
triggerClass: function triggerClass() {
|
|
return this.type.indexOf('time') !== -1 ? 'el-icon-time' : 'el-icon-date';
|
|
},
|
|
selectionMode: function selectionMode() {
|
|
if (this.type === 'week') {
|
|
return 'week';
|
|
} else if (this.type === 'month') {
|
|
return 'month';
|
|
} else if (this.type === 'year') {
|
|
return 'year';
|
|
}
|
|
|
|
return 'day';
|
|
},
|
|
haveTrigger: function haveTrigger() {
|
|
if (typeof this.showTrigger !== 'undefined') {
|
|
return this.showTrigger;
|
|
}
|
|
return HAVE_TRIGGER_TYPES.indexOf(this.type) !== -1;
|
|
},
|
|
|
|
|
|
displayValue: {
|
|
get: function get() {
|
|
var value = this.currentValue;
|
|
if (!value) return;
|
|
var formatter = (TYPE_VALUE_RESOLVER_MAP[this.type] || TYPE_VALUE_RESOLVER_MAP['default']).formatter;
|
|
var format = DEFAULT_FORMATS[this.type];
|
|
|
|
return formatter(value, this.format || format, this.rangeSeparator);
|
|
},
|
|
set: function set(value) {
|
|
if (value) {
|
|
var type = this.type;
|
|
var parser = (TYPE_VALUE_RESOLVER_MAP[type] || TYPE_VALUE_RESOLVER_MAP['default']).parser;
|
|
var parsedValue = parser(value, this.format || DEFAULT_FORMATS[type], this.rangeSeparator);
|
|
|
|
if (parsedValue && this.picker) {
|
|
this.picker.value = parsedValue;
|
|
}
|
|
} else {
|
|
this.picker.value = value;
|
|
}
|
|
this.$forceUpdate();
|
|
}
|
|
}
|
|
},
|
|
|
|
created: function created() {
|
|
// vue-popper
|
|
this.popperOptions = {
|
|
boundariesPadding: 0,
|
|
gpuAcceleration: false
|
|
};
|
|
this.placement = PLACEMENT_MAP[this.align] || PLACEMENT_MAP.left;
|
|
},
|
|
|
|
|
|
methods: {
|
|
handleMouseEnterIcon: function handleMouseEnterIcon() {
|
|
if (this.readonly || this.disabled) return;
|
|
if (!this.valueIsEmpty && this.clearable) {
|
|
this.showClose = true;
|
|
}
|
|
},
|
|
handleClickIcon: function handleClickIcon() {
|
|
if (this.readonly || this.disabled) return;
|
|
if (this.showClose) {
|
|
this.currentValue = '';
|
|
this.showClose = false;
|
|
} else {
|
|
this.pickerVisible = !this.pickerVisible;
|
|
}
|
|
},
|
|
dateChanged: function dateChanged(dateA, dateB) {
|
|
if (Array.isArray(dateA)) {
|
|
var len = dateA.length;
|
|
if (!dateB) return true;
|
|
while (len--) {
|
|
if (!(0, _util.equalDate)(dateA[len], dateB[len])) return true;
|
|
}
|
|
} else {
|
|
if (!(0, _util.equalDate)(dateA, dateB)) return true;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
handleClose: function handleClose() {
|
|
this.pickerVisible = false;
|
|
},
|
|
handleFocus: function handleFocus() {
|
|
var type = this.type;
|
|
|
|
if (HAVE_TRIGGER_TYPES.indexOf(type) !== -1 && !this.pickerVisible) {
|
|
this.pickerVisible = true;
|
|
}
|
|
this.$emit('focus', this);
|
|
},
|
|
handleBlur: function handleBlur() {
|
|
this.$emit('blur', this);
|
|
},
|
|
handleKeydown: function handleKeydown(event) {
|
|
var keyCode = event.keyCode;
|
|
|
|
// tab
|
|
if (keyCode === 9) {
|
|
this.pickerVisible = false;
|
|
}
|
|
},
|
|
hidePicker: function hidePicker() {
|
|
if (this.picker) {
|
|
this.picker.resetView && this.picker.resetView();
|
|
this.pickerVisible = this.picker.visible = false;
|
|
this.destroyPopper();
|
|
}
|
|
},
|
|
showPicker: function showPicker() {
|
|
var _this = this;
|
|
|
|
if (this.$isServer) return;
|
|
if (!this.picker) {
|
|
(function () {
|
|
_this.panel.defaultValue = _this.currentValue;
|
|
_this.picker = new _vue2.default(_this.panel).$mount();
|
|
_this.picker.popperClass = _this.popperClass;
|
|
_this.popperElm = _this.picker.$el;
|
|
_this.picker.width = _this.reference.getBoundingClientRect().width;
|
|
_this.picker.showTime = _this.type === 'datetime' || _this.type === 'datetimerange';
|
|
_this.picker.selectionMode = _this.selectionMode;
|
|
if (_this.format) {
|
|
_this.picker.format = _this.format;
|
|
}
|
|
|
|
var updateOptions = function updateOptions() {
|
|
var options = _this.pickerOptions;
|
|
|
|
if (options && options.selectableRange) {
|
|
(function () {
|
|
var ranges = options.selectableRange;
|
|
var parser = TYPE_VALUE_RESOLVER_MAP.datetimerange.parser;
|
|
var format = DEFAULT_FORMATS.timerange;
|
|
|
|
ranges = Array.isArray(ranges) ? ranges : [ranges];
|
|
_this.picker.selectableRange = ranges.map(function (range) {
|
|
return parser(range, format, _this.rangeSeparator);
|
|
});
|
|
})();
|
|
}
|
|
|
|
for (var option in options) {
|
|
if (options.hasOwnProperty(option) &&
|
|
// 忽略 time-picker 的该配置项
|
|
option !== 'selectableRange') {
|
|
_this.picker[option] = options[option];
|
|
}
|
|
}
|
|
};
|
|
updateOptions();
|
|
_this.$watch('pickerOptions', function () {
|
|
return updateOptions();
|
|
}, { deep: true });
|
|
|
|
_this.$el.appendChild(_this.picker.$el);
|
|
_this.pickerVisible = _this.picker.visible = true;
|
|
_this.picker.resetView && _this.picker.resetView();
|
|
|
|
_this.picker.$on('dodestroy', _this.doDestroy);
|
|
_this.picker.$on('pick', function (date) {
|
|
var visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
|
|
_this.$emit('input', date);
|
|
_this.pickerVisible = _this.picker.visible = visible;
|
|
_this.picker.resetView && _this.picker.resetView();
|
|
});
|
|
|
|
_this.picker.$on('select-range', function (start, end) {
|
|
_this.refInput.setSelectionRange(start, end);
|
|
_this.refInput.focus();
|
|
});
|
|
})();
|
|
} else {
|
|
this.pickerVisible = this.picker.visible = true;
|
|
}
|
|
|
|
this.updatePopper();
|
|
|
|
if (this.currentValue instanceof Date) {
|
|
this.picker.date = new Date(this.currentValue.getTime());
|
|
} else {
|
|
this.picker.value = this.currentValue;
|
|
}
|
|
this.picker.resetView && this.picker.resetView();
|
|
|
|
this.$nextTick(function () {
|
|
_this.picker.ajustScrollTop && _this.picker.ajustScrollTop();
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
|
|
/***/ 104:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
exports.limitRange = exports.getRangeHours = exports.nextMonth = exports.prevMonth = exports.getWeekNumber = exports.getStartDateOfMonth = exports.DAY_DURATION = exports.getFirstDayOfMonth = exports.getDayCountOfMonth = exports.parseDate = exports.formatDate = exports.isDate = exports.toDate = exports.equalDate = undefined;
|
|
|
|
var _date = __webpack_require__(105);
|
|
|
|
var _date2 = _interopRequireDefault(_date);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var newArray = function newArray(start, end) {
|
|
var result = [];
|
|
for (var i = start; i <= end; i++) {
|
|
result.push(i);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
var equalDate = exports.equalDate = function equalDate(dateA, dateB) {
|
|
return dateA === dateB || new Date(dateA).getTime() === new Date(dateB).getTime();
|
|
};
|
|
|
|
var toDate = exports.toDate = function toDate(date) {
|
|
return isDate(date) ? new Date(date) : null;
|
|
};
|
|
|
|
var isDate = exports.isDate = function isDate(date) {
|
|
if (date === null || date === undefined) return false;
|
|
if (isNaN(new Date(date).getTime())) return false;
|
|
return true;
|
|
};
|
|
|
|
var formatDate = exports.formatDate = function formatDate(date, format) {
|
|
date = toDate(date);
|
|
if (!date) return '';
|
|
return _date2.default.format(date, format || 'yyyy-MM-dd');
|
|
};
|
|
|
|
var parseDate = exports.parseDate = function parseDate(string, format) {
|
|
return _date2.default.parse(string, format || 'yyyy-MM-dd');
|
|
};
|
|
|
|
var getDayCountOfMonth = exports.getDayCountOfMonth = function getDayCountOfMonth(year, month) {
|
|
if (month === 3 || month === 5 || month === 8 || month === 10) {
|
|
return 30;
|
|
}
|
|
|
|
if (month === 1) {
|
|
if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
|
|
return 29;
|
|
} else {
|
|
return 28;
|
|
}
|
|
}
|
|
|
|
return 31;
|
|
};
|
|
|
|
var getFirstDayOfMonth = exports.getFirstDayOfMonth = function getFirstDayOfMonth(date) {
|
|
var temp = new Date(date.getTime());
|
|
temp.setDate(1);
|
|
return temp.getDay();
|
|
};
|
|
|
|
var DAY_DURATION = exports.DAY_DURATION = 86400000;
|
|
|
|
var getStartDateOfMonth = exports.getStartDateOfMonth = function getStartDateOfMonth(year, month) {
|
|
var result = new Date(year, month, 1);
|
|
var day = result.getDay();
|
|
|
|
if (day === 0) {
|
|
result.setTime(result.getTime() - DAY_DURATION * 7);
|
|
} else {
|
|
result.setTime(result.getTime() - DAY_DURATION * day);
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
var getWeekNumber = exports.getWeekNumber = function getWeekNumber(src) {
|
|
var date = new Date(src.getTime());
|
|
date.setHours(0, 0, 0, 0);
|
|
// Thursday in current week decides the year.
|
|
date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
|
|
// January 4 is always in week 1.
|
|
var week1 = new Date(date.getFullYear(), 0, 4);
|
|
// Adjust to Thursday in week 1 and count number of weeks from date to week 1.
|
|
return 1 + Math.round(((date.getTime() - week1.getTime()) / 86400000 - 3 + (week1.getDay() + 6) % 7) / 7);
|
|
};
|
|
|
|
var prevMonth = exports.prevMonth = function prevMonth(src) {
|
|
var year = src.getFullYear();
|
|
var month = src.getMonth();
|
|
var date = src.getDate();
|
|
|
|
var newYear = month === 0 ? year - 1 : year;
|
|
var newMonth = month === 0 ? 11 : month - 1;
|
|
|
|
var newMonthDayCount = getDayCountOfMonth(newYear, newMonth);
|
|
if (newMonthDayCount < date) {
|
|
src.setDate(newMonthDayCount);
|
|
}
|
|
|
|
src.setMonth(newMonth);
|
|
src.setFullYear(newYear);
|
|
|
|
return new Date(src.getTime());
|
|
};
|
|
|
|
var nextMonth = exports.nextMonth = function nextMonth(src) {
|
|
var year = src.getFullYear();
|
|
var month = src.getMonth();
|
|
var date = src.getDate();
|
|
|
|
var newYear = month === 11 ? year + 1 : year;
|
|
var newMonth = month === 11 ? 0 : month + 1;
|
|
|
|
var newMonthDayCount = getDayCountOfMonth(newYear, newMonth);
|
|
if (newMonthDayCount < date) {
|
|
src.setDate(newMonthDayCount);
|
|
}
|
|
|
|
src.setMonth(newMonth);
|
|
src.setFullYear(newYear);
|
|
|
|
return new Date(src.getTime());
|
|
};
|
|
|
|
var getRangeHours = exports.getRangeHours = function getRangeHours(ranges) {
|
|
var hours = [];
|
|
var disabledHours = [];
|
|
|
|
(ranges || []).forEach(function (range) {
|
|
var value = range.map(function (date) {
|
|
return date.getHours();
|
|
});
|
|
|
|
disabledHours = disabledHours.concat(newArray(value[0], value[1]));
|
|
});
|
|
|
|
if (disabledHours.length) {
|
|
for (var i = 0; i < 24; i++) {
|
|
hours[i] = disabledHours.indexOf(i) === -1;
|
|
}
|
|
} else {
|
|
for (var _i = 0; _i < 24; _i++) {
|
|
hours[_i] = false;
|
|
}
|
|
}
|
|
|
|
return hours;
|
|
};
|
|
|
|
var limitRange = exports.limitRange = function limitRange(date, ranges) {
|
|
var format = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'yyyy-MM-dd HH:mm:ss';
|
|
|
|
if (!ranges || !ranges.length) return date;
|
|
|
|
var len = ranges.length;
|
|
|
|
date = _date2.default.parse(_date2.default.format(date, format), format);
|
|
for (var i = 0; i < len; i++) {
|
|
var range = ranges[i];
|
|
if (date >= range[0] && date <= range[1]) {
|
|
return date;
|
|
}
|
|
}
|
|
|
|
var maxDate = ranges[0][0];
|
|
var minDate = ranges[0][0];
|
|
|
|
ranges.forEach(function (range) {
|
|
minDate = new Date(Math.min(range[0], minDate));
|
|
maxDate = new Date(Math.max(range[1], maxDate));
|
|
});
|
|
|
|
return date < minDate ? minDate : maxDate;
|
|
};
|
|
|
|
/***/ },
|
|
|
|
/***/ 105:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports = require("element-ui/lib/utils/date");
|
|
|
|
/***/ },
|
|
|
|
/***/ 106:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('el-input', {
|
|
directives: [{
|
|
name: "clickoutside",
|
|
rawName: "v-clickoutside",
|
|
value: (_vm.handleClose),
|
|
expression: "handleClose"
|
|
}],
|
|
ref: "reference",
|
|
staticClass: "el-date-editor",
|
|
class: 'el-date-editor--' + _vm.type,
|
|
attrs: {
|
|
"readonly": !_vm.editable || _vm.readonly,
|
|
"disabled": _vm.disabled,
|
|
"size": _vm.size,
|
|
"placeholder": _vm.placeholder,
|
|
"value": _vm.displayValue,
|
|
"validateEvent": false
|
|
},
|
|
on: {
|
|
"focus": _vm.handleFocus,
|
|
"blur": _vm.handleBlur
|
|
},
|
|
nativeOn: {
|
|
"keydown": function($event) {
|
|
_vm.handleKeydown($event)
|
|
},
|
|
"change": function($event) {
|
|
_vm.displayValue = $event.target.value
|
|
}
|
|
}
|
|
}, [(_vm.haveTrigger) ? _c('i', {
|
|
staticClass: "el-input__icon",
|
|
class: [_vm.showClose ? 'el-icon-close' : _vm.triggerClass],
|
|
on: {
|
|
"click": _vm.handleClickIcon,
|
|
"mouseenter": _vm.handleMouseEnterIcon,
|
|
"mouseleave": function($event) {
|
|
_vm.showClose = false
|
|
}
|
|
},
|
|
slot: "icon"
|
|
}) : _vm._e()])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ },
|
|
|
|
/***/ 109:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(110),
|
|
/* template */
|
|
__webpack_require__(114),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ },
|
|
|
|
/***/ 110:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _util = __webpack_require__(104);
|
|
|
|
var _locale = __webpack_require__(60);
|
|
|
|
var _locale2 = _interopRequireDefault(_locale);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
mixins: [_locale2.default],
|
|
|
|
components: {
|
|
TimeSpinner: __webpack_require__(111)
|
|
},
|
|
|
|
props: {
|
|
pickerWidth: {},
|
|
date: {
|
|
default: function _default() {
|
|
return new Date();
|
|
}
|
|
},
|
|
visible: Boolean
|
|
},
|
|
|
|
watch: {
|
|
visible: function visible(val) {
|
|
this.currentVisible = val;
|
|
},
|
|
pickerWidth: function pickerWidth(val) {
|
|
this.width = val;
|
|
},
|
|
value: function value(newVal) {
|
|
var _this = this;
|
|
|
|
var date = void 0;
|
|
if (newVal instanceof Date) {
|
|
date = (0, _util.limitRange)(newVal, this.selectableRange);
|
|
} else if (!newVal) {
|
|
date = new Date();
|
|
}
|
|
|
|
this.handleChange({
|
|
hours: date.getHours(),
|
|
minutes: date.getMinutes(),
|
|
seconds: date.getSeconds()
|
|
});
|
|
this.$nextTick(function (_) {
|
|
return _this.ajustScrollTop();
|
|
});
|
|
},
|
|
selectableRange: function selectableRange(val) {
|
|
this.$refs.spinner.selectableRange = val;
|
|
}
|
|
},
|
|
|
|
data: function data() {
|
|
return {
|
|
popperClass: '',
|
|
format: 'HH:mm:ss',
|
|
value: '',
|
|
hours: 0,
|
|
minutes: 0,
|
|
seconds: 0,
|
|
selectableRange: [],
|
|
currentDate: this.$options.defaultValue || this.date || new Date(),
|
|
currentVisible: this.visible || false,
|
|
width: this.pickerWidth || 0
|
|
};
|
|
},
|
|
|
|
|
|
computed: {
|
|
showSeconds: function showSeconds() {
|
|
return (this.format || '').indexOf('ss') !== -1;
|
|
}
|
|
},
|
|
|
|
methods: {
|
|
handleClear: function handleClear() {
|
|
this.$emit('pick');
|
|
},
|
|
handleCancel: function handleCancel() {
|
|
this.$emit('pick');
|
|
},
|
|
handleChange: function handleChange(date) {
|
|
if (date.hours !== undefined) {
|
|
this.currentDate.setHours(date.hours);
|
|
this.hours = this.currentDate.getHours();
|
|
}
|
|
if (date.minutes !== undefined) {
|
|
this.currentDate.setMinutes(date.minutes);
|
|
this.minutes = this.currentDate.getMinutes();
|
|
}
|
|
if (date.seconds !== undefined) {
|
|
this.currentDate.setSeconds(date.seconds);
|
|
this.seconds = this.currentDate.getSeconds();
|
|
}
|
|
|
|
this.handleConfirm(true);
|
|
},
|
|
setSelectionRange: function setSelectionRange(start, end) {
|
|
this.$emit('select-range', start, end);
|
|
},
|
|
handleConfirm: function handleConfirm() {
|
|
var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
var first = arguments[1];
|
|
|
|
if (first) return;
|
|
var date = new Date((0, _util.limitRange)(this.currentDate, this.selectableRange, 'HH:mm:ss'));
|
|
this.$emit('pick', date, visible, first);
|
|
},
|
|
ajustScrollTop: function ajustScrollTop() {
|
|
return this.$refs.spinner.ajustScrollTop();
|
|
}
|
|
},
|
|
|
|
created: function created() {
|
|
this.hours = this.currentDate.getHours();
|
|
this.minutes = this.currentDate.getMinutes();
|
|
this.seconds = this.currentDate.getSeconds();
|
|
},
|
|
mounted: function mounted() {
|
|
var _this2 = this;
|
|
|
|
this.$nextTick(function () {
|
|
return _this2.handleConfirm(true, true);
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
|
|
/***/ 111:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(112),
|
|
/* template */
|
|
__webpack_require__(113),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ },
|
|
|
|
/***/ 112:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _util = __webpack_require__(104);
|
|
|
|
var _scrollbar = __webpack_require__(15);
|
|
|
|
var _scrollbar2 = _interopRequireDefault(_scrollbar);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
exports.default = {
|
|
components: { ElScrollbar: _scrollbar2.default },
|
|
|
|
props: {
|
|
hours: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
|
|
minutes: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
|
|
seconds: {
|
|
type: Number,
|
|
default: 0
|
|
},
|
|
|
|
showSeconds: {
|
|
type: Boolean,
|
|
default: true
|
|
}
|
|
},
|
|
|
|
watch: {
|
|
hoursPrivate: function hoursPrivate(newVal, oldVal) {
|
|
if (!(newVal >= 0 && newVal <= 23)) {
|
|
this.hoursPrivate = oldVal;
|
|
}
|
|
this.ajustElTop('hour', newVal);
|
|
this.$emit('change', { hours: newVal });
|
|
},
|
|
minutesPrivate: function minutesPrivate(newVal, oldVal) {
|
|
if (!(newVal >= 0 && newVal <= 59)) {
|
|
this.minutesPrivate = oldVal;
|
|
}
|
|
this.ajustElTop('minute', newVal);
|
|
this.$emit('change', { minutes: newVal });
|
|
},
|
|
secondsPrivate: function secondsPrivate(newVal, oldVal) {
|
|
if (!(newVal >= 0 && newVal <= 59)) {
|
|
this.secondsPrivate = oldVal;
|
|
}
|
|
this.ajustElTop('second', newVal);
|
|
this.$emit('change', { seconds: newVal });
|
|
}
|
|
},
|
|
|
|
computed: {
|
|
hoursList: function hoursList() {
|
|
return (0, _util.getRangeHours)(this.selectableRange);
|
|
},
|
|
hourEl: function hourEl() {
|
|
return this.$refs.hour.wrap;
|
|
},
|
|
minuteEl: function minuteEl() {
|
|
return this.$refs.minute.wrap;
|
|
},
|
|
secondEl: function secondEl() {
|
|
return this.$refs.second.wrap;
|
|
}
|
|
},
|
|
|
|
data: function data() {
|
|
return {
|
|
hoursPrivate: 0,
|
|
minutesPrivate: 0,
|
|
secondsPrivate: 0,
|
|
selectableRange: []
|
|
};
|
|
},
|
|
mounted: function mounted() {
|
|
var _this = this;
|
|
|
|
this.$nextTick(function () {
|
|
_this.bindScrollEvent();
|
|
});
|
|
},
|
|
|
|
|
|
methods: {
|
|
handleClick: function handleClick(type, value, disabled) {
|
|
if (value.disabled) {
|
|
return;
|
|
}
|
|
|
|
this[type + 'Private'] = value.value >= 0 ? value.value : value;
|
|
|
|
this.emitSelectRange(type);
|
|
},
|
|
emitSelectRange: function emitSelectRange(type) {
|
|
if (type === 'hours') {
|
|
this.$emit('select-range', 0, 2);
|
|
} else if (type === 'minutes') {
|
|
this.$emit('select-range', 3, 5);
|
|
} else if (type === 'seconds') {
|
|
this.$emit('select-range', 6, 8);
|
|
}
|
|
},
|
|
bindScrollEvent: function bindScrollEvent() {
|
|
var _this2 = this;
|
|
|
|
var bindFuntion = function bindFuntion(type) {
|
|
_this2[type + 'El'].onscroll = function (e) {
|
|
return _this2.handleScroll(type, e);
|
|
};
|
|
};
|
|
bindFuntion('hour');
|
|
bindFuntion('minute');
|
|
bindFuntion('second');
|
|
},
|
|
handleScroll: function handleScroll(type) {
|
|
var ajust = {};
|
|
ajust[type + 's'] = Math.min(Math.floor((this[type + 'El'].scrollTop - 80) / 32 + 3), 59);
|
|
this.$emit('change', ajust);
|
|
},
|
|
ajustScrollTop: function ajustScrollTop() {
|
|
this.ajustElTop('hour', this.hours);
|
|
this.ajustElTop('minute', this.minutes);
|
|
this.ajustElTop('second', this.seconds);
|
|
},
|
|
ajustElTop: function ajustElTop(type, value) {
|
|
this[type + 'El'].scrollTop = Math.max(0, (value - 2.5) * 32 + 80);
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
|
|
/***/ 113:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('div', {
|
|
staticClass: "el-time-spinner",
|
|
class: {
|
|
'has-seconds': _vm.showSeconds
|
|
}
|
|
}, [_c('el-scrollbar', {
|
|
ref: "hour",
|
|
staticClass: "el-time-spinner__wrapper",
|
|
attrs: {
|
|
"wrap-style": "max-height: inherit;",
|
|
"view-class": "el-time-spinner__list",
|
|
"noresize": "",
|
|
"tag": "ul"
|
|
},
|
|
nativeOn: {
|
|
"mouseenter": function($event) {
|
|
_vm.emitSelectRange('hours')
|
|
}
|
|
}
|
|
}, _vm._l((_vm.hoursList), function(disabled, hour) {
|
|
return _c('li', {
|
|
staticClass: "el-time-spinner__item",
|
|
class: {
|
|
'active': hour === _vm.hours, 'disabled': disabled
|
|
},
|
|
attrs: {
|
|
"track-by": "hour"
|
|
},
|
|
domProps: {
|
|
"textContent": _vm._s(hour)
|
|
},
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.handleClick('hours', {
|
|
value: hour,
|
|
disabled: disabled
|
|
}, true)
|
|
}
|
|
}
|
|
})
|
|
})), _c('el-scrollbar', {
|
|
ref: "minute",
|
|
staticClass: "el-time-spinner__wrapper",
|
|
attrs: {
|
|
"wrap-style": "max-height: inherit;",
|
|
"view-class": "el-time-spinner__list",
|
|
"noresize": "",
|
|
"tag": "ul"
|
|
},
|
|
nativeOn: {
|
|
"mouseenter": function($event) {
|
|
_vm.emitSelectRange('minutes')
|
|
}
|
|
}
|
|
}, _vm._l((60), function(minute, key) {
|
|
return _c('li', {
|
|
staticClass: "el-time-spinner__item",
|
|
class: {
|
|
'active': key === _vm.minutes
|
|
},
|
|
domProps: {
|
|
"textContent": _vm._s(key)
|
|
},
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.handleClick('minutes', key, true)
|
|
}
|
|
}
|
|
})
|
|
})), _c('el-scrollbar', {
|
|
directives: [{
|
|
name: "show",
|
|
rawName: "v-show",
|
|
value: (_vm.showSeconds),
|
|
expression: "showSeconds"
|
|
}],
|
|
ref: "second",
|
|
staticClass: "el-time-spinner__wrapper",
|
|
attrs: {
|
|
"wrap-style": "max-height: inherit;",
|
|
"view-class": "el-time-spinner__list",
|
|
"noresize": "",
|
|
"tag": "ul"
|
|
},
|
|
nativeOn: {
|
|
"mouseenter": function($event) {
|
|
_vm.emitSelectRange('seconds')
|
|
}
|
|
}
|
|
}, _vm._l((60), function(second, key) {
|
|
return _c('li', {
|
|
staticClass: "el-time-spinner__item",
|
|
class: {
|
|
'active': key === _vm.seconds
|
|
},
|
|
domProps: {
|
|
"textContent": _vm._s(key)
|
|
},
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.handleClick('seconds', key, true)
|
|
}
|
|
}
|
|
})
|
|
}))], 1)
|
|
},staticRenderFns: []}
|
|
|
|
/***/ },
|
|
|
|
/***/ 114:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('transition', {
|
|
attrs: {
|
|
"name": "el-zoom-in-top"
|
|
},
|
|
on: {
|
|
"after-leave": function($event) {
|
|
_vm.$emit('dodestroy')
|
|
}
|
|
}
|
|
}, [_c('div', {
|
|
directives: [{
|
|
name: "show",
|
|
rawName: "v-show",
|
|
value: (_vm.currentVisible),
|
|
expression: "currentVisible"
|
|
}],
|
|
staticClass: "el-time-panel",
|
|
class: _vm.popperClass,
|
|
style: ({
|
|
width: _vm.width + 'px'
|
|
})
|
|
}, [_c('div', {
|
|
staticClass: "el-time-panel__content",
|
|
class: {
|
|
'has-seconds': _vm.showSeconds
|
|
}
|
|
}, [_c('time-spinner', {
|
|
ref: "spinner",
|
|
attrs: {
|
|
"show-seconds": _vm.showSeconds,
|
|
"hours": _vm.hours,
|
|
"minutes": _vm.minutes,
|
|
"seconds": _vm.seconds
|
|
},
|
|
on: {
|
|
"change": _vm.handleChange,
|
|
"select-range": _vm.setSelectionRange
|
|
}
|
|
})], 1), _c('div', {
|
|
staticClass: "el-time-panel__footer"
|
|
}, [_c('button', {
|
|
staticClass: "el-time-panel__btn cancel",
|
|
attrs: {
|
|
"type": "button"
|
|
},
|
|
on: {
|
|
"click": _vm.handleCancel
|
|
}
|
|
}, [_vm._v(_vm._s(_vm.t('el.datepicker.cancel')))]), _c('button', {
|
|
staticClass: "el-time-panel__btn confirm",
|
|
attrs: {
|
|
"type": "button"
|
|
},
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.handleConfirm()
|
|
}
|
|
}
|
|
}, [_vm._v(_vm._s(_vm.t('el.datepicker.confirm')))])])])])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ },
|
|
|
|
/***/ 330:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _timePicker = __webpack_require__(331);
|
|
|
|
var _timePicker2 = _interopRequireDefault(_timePicker);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/* istanbul ignore next */
|
|
_timePicker2.default.install = function (Vue) {
|
|
Vue.component(_timePicker2.default.name, _timePicker2.default);
|
|
};
|
|
|
|
exports.default = _timePicker2.default;
|
|
|
|
/***/ },
|
|
|
|
/***/ 331:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _picker = __webpack_require__(102);
|
|
|
|
var _picker2 = _interopRequireDefault(_picker);
|
|
|
|
var _time = __webpack_require__(109);
|
|
|
|
var _time2 = _interopRequireDefault(_time);
|
|
|
|
var _timeRange = __webpack_require__(332);
|
|
|
|
var _timeRange2 = _interopRequireDefault(_timeRange);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = {
|
|
mixins: [_picker2.default],
|
|
|
|
name: 'ElTimePicker',
|
|
|
|
props: {
|
|
isRange: Boolean
|
|
},
|
|
|
|
data: function data() {
|
|
return {
|
|
type: ''
|
|
};
|
|
},
|
|
created: function created() {
|
|
this.type = this.isRange ? 'timerange' : 'time';
|
|
this.panel = this.isRange ? _timeRange2.default : _time2.default;
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
|
|
/***/ 332:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
var Component = __webpack_require__(3)(
|
|
/* script */
|
|
__webpack_require__(333),
|
|
/* template */
|
|
__webpack_require__(334),
|
|
/* scopeId */
|
|
null,
|
|
/* cssModules */
|
|
null
|
|
)
|
|
|
|
module.exports = Component.exports
|
|
|
|
|
|
/***/ },
|
|
|
|
/***/ 333:
|
|
/***/ function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
exports.__esModule = true;
|
|
|
|
var _util = __webpack_require__(104);
|
|
|
|
var _locale = __webpack_require__(60);
|
|
|
|
var _locale2 = _interopRequireDefault(_locale);
|
|
|
|
var _timeSpinner = __webpack_require__(111);
|
|
|
|
var _timeSpinner2 = _interopRequireDefault(_timeSpinner);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var MIN_TIME = (0, _util.parseDate)('00:00:00', 'HH:mm:ss'); //
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
|
|
var MAX_TIME = (0, _util.parseDate)('23:59:59', 'HH:mm:ss');
|
|
var isDisabled = function isDisabled(minTime, maxTime) {
|
|
var minValue = minTime.getHours() * 3600 + minTime.getMinutes() * 60 + minTime.getSeconds();
|
|
var maxValue = maxTime.getHours() * 3600 + maxTime.getMinutes() * 60 + maxTime.getSeconds();
|
|
|
|
return minValue > maxValue;
|
|
};
|
|
var clacTime = function clacTime(time) {
|
|
time = Array.isArray(time) ? time : [time];
|
|
var minTime = time[0] || new Date();
|
|
var date = new Date();
|
|
date.setHours(date.getHours() + 1);
|
|
var maxTime = time[1] || date;
|
|
|
|
if (minTime > maxTime) return clacTime();
|
|
return { minTime: minTime, maxTime: maxTime };
|
|
};
|
|
|
|
exports.default = {
|
|
mixins: [_locale2.default],
|
|
|
|
components: { TimeSpinner: _timeSpinner2.default },
|
|
|
|
computed: {
|
|
showSeconds: function showSeconds() {
|
|
return (this.format || '').indexOf('ss') !== -1;
|
|
}
|
|
},
|
|
|
|
props: ['value'],
|
|
|
|
data: function data() {
|
|
var time = clacTime(this.$options.defaultValue);
|
|
|
|
return {
|
|
popperClass: '',
|
|
minTime: time.minTime,
|
|
maxTime: time.maxTime,
|
|
btnDisabled: isDisabled(time.minTime, time.maxTime),
|
|
maxHours: time.maxTime.getHours(),
|
|
maxMinutes: time.maxTime.getMinutes(),
|
|
maxSeconds: time.maxTime.getSeconds(),
|
|
minHours: time.minTime.getHours(),
|
|
minMinutes: time.minTime.getMinutes(),
|
|
minSeconds: time.minTime.getSeconds(),
|
|
format: 'HH:mm:ss',
|
|
visible: false,
|
|
width: 0
|
|
};
|
|
},
|
|
|
|
|
|
watch: {
|
|
value: function value(newVal) {
|
|
var _this = this;
|
|
|
|
this.panelCreated();
|
|
this.$nextTick(function (_) {
|
|
return _this.ajustScrollTop();
|
|
});
|
|
}
|
|
},
|
|
|
|
methods: {
|
|
panelCreated: function panelCreated() {
|
|
var time = clacTime(this.value);
|
|
if (time.minTime === this.minTime && time.maxTime === this.maxTime) {
|
|
return;
|
|
}
|
|
|
|
this.handleMinChange({
|
|
hours: time.minTime.getHours(),
|
|
minutes: time.minTime.getMinutes(),
|
|
seconds: time.minTime.getSeconds()
|
|
});
|
|
this.handleMaxChange({
|
|
hours: time.maxTime.getHours(),
|
|
minutes: time.maxTime.getMinutes(),
|
|
seconds: time.maxTime.getSeconds()
|
|
});
|
|
},
|
|
handleClear: function handleClear() {
|
|
this.handleCancel();
|
|
},
|
|
handleCancel: function handleCancel() {
|
|
this.$emit('pick');
|
|
},
|
|
handleChange: function handleChange() {
|
|
if (this.minTime > this.maxTime) return;
|
|
MIN_TIME.setFullYear(this.minTime.getFullYear());
|
|
MIN_TIME.setMonth(this.minTime.getMonth(), this.minTime.getDate());
|
|
MAX_TIME.setFullYear(this.maxTime.getFullYear());
|
|
MAX_TIME.setMonth(this.maxTime.getMonth(), this.maxTime.getDate());
|
|
this.$refs.minSpinner.selectableRange = [[MIN_TIME, this.maxTime]];
|
|
this.$refs.maxSpinner.selectableRange = [[this.minTime, MAX_TIME]];
|
|
this.handleConfirm(true);
|
|
},
|
|
handleMaxChange: function handleMaxChange(date) {
|
|
if (date.hours !== undefined) {
|
|
this.maxTime.setHours(date.hours);
|
|
this.maxHours = this.maxTime.getHours();
|
|
}
|
|
if (date.minutes !== undefined) {
|
|
this.maxTime.setMinutes(date.minutes);
|
|
this.maxMinutes = this.maxTime.getMinutes();
|
|
}
|
|
if (date.seconds !== undefined) {
|
|
this.maxTime.setSeconds(date.seconds);
|
|
this.maxSeconds = this.maxTime.getSeconds();
|
|
}
|
|
this.handleChange();
|
|
},
|
|
handleMinChange: function handleMinChange(date) {
|
|
if (date.hours !== undefined) {
|
|
this.minTime.setHours(date.hours);
|
|
this.minHours = this.minTime.getHours();
|
|
}
|
|
if (date.minutes !== undefined) {
|
|
this.minTime.setMinutes(date.minutes);
|
|
this.minMinutes = this.minTime.getMinutes();
|
|
}
|
|
if (date.seconds !== undefined) {
|
|
this.minTime.setSeconds(date.seconds);
|
|
this.minSeconds = this.minTime.getSeconds();
|
|
}
|
|
|
|
this.handleChange();
|
|
},
|
|
setMinSelectionRange: function setMinSelectionRange(start, end) {
|
|
this.$emit('select-range', start, end);
|
|
},
|
|
setMaxSelectionRange: function setMaxSelectionRange(start, end) {
|
|
this.$emit('select-range', start + 11, end + 11);
|
|
},
|
|
handleConfirm: function handleConfirm() {
|
|
var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
var first = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
|
|
var minSelectableRange = this.$refs.minSpinner.selectableRange;
|
|
var maxSelectableRange = this.$refs.maxSpinner.selectableRange;
|
|
|
|
this.minTime = (0, _util.limitRange)(this.minTime, minSelectableRange);
|
|
this.maxTime = (0, _util.limitRange)(this.maxTime, maxSelectableRange);
|
|
|
|
if (first) return;
|
|
this.$emit('pick', [this.minTime, this.maxTime], visible, first);
|
|
},
|
|
ajustScrollTop: function ajustScrollTop() {
|
|
this.$refs.minSpinner.ajustScrollTop();
|
|
this.$refs.maxSpinner.ajustScrollTop();
|
|
}
|
|
},
|
|
|
|
mounted: function mounted() {
|
|
var _this2 = this;
|
|
|
|
this.$nextTick(function () {
|
|
return _this2.handleConfirm(true, true);
|
|
});
|
|
}
|
|
};
|
|
|
|
/***/ },
|
|
|
|
/***/ 334:
|
|
/***/ function(module, exports) {
|
|
|
|
module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
|
|
return _c('transition', {
|
|
attrs: {
|
|
"name": "el-zoom-in-top"
|
|
},
|
|
on: {
|
|
"before-enter": _vm.panelCreated,
|
|
"after-leave": function($event) {
|
|
_vm.$emit('dodestroy')
|
|
}
|
|
}
|
|
}, [_c('div', {
|
|
directives: [{
|
|
name: "show",
|
|
rawName: "v-show",
|
|
value: (_vm.visible),
|
|
expression: "visible"
|
|
}],
|
|
staticClass: "el-time-range-picker el-picker-panel",
|
|
class: _vm.popperClass,
|
|
style: ({
|
|
width: _vm.width + 'px'
|
|
})
|
|
}, [_c('div', {
|
|
staticClass: "el-time-range-picker__content"
|
|
}, [_c('div', {
|
|
staticClass: "el-time-range-picker__cell"
|
|
}, [_c('div', {
|
|
staticClass: "el-time-range-picker__header"
|
|
}, [_vm._v(_vm._s(_vm.t('el.datepicker.startTime')))]), _c('div', {
|
|
staticClass: "el-time-range-picker__body el-time-panel__content",
|
|
class: {
|
|
'has-seconds': _vm.showSeconds
|
|
}
|
|
}, [_c('time-spinner', {
|
|
ref: "minSpinner",
|
|
attrs: {
|
|
"show-seconds": _vm.showSeconds,
|
|
"hours": _vm.minHours,
|
|
"minutes": _vm.minMinutes,
|
|
"seconds": _vm.minSeconds
|
|
},
|
|
on: {
|
|
"change": _vm.handleMinChange,
|
|
"select-range": _vm.setMinSelectionRange
|
|
}
|
|
})], 1)]), _c('div', {
|
|
staticClass: "el-time-range-picker__cell"
|
|
}, [_c('div', {
|
|
staticClass: "el-time-range-picker__header"
|
|
}, [_vm._v(_vm._s(_vm.t('el.datepicker.endTime')))]), _c('div', {
|
|
staticClass: "el-time-range-picker__body el-time-panel__content",
|
|
class: {
|
|
'has-seconds': _vm.showSeconds
|
|
}
|
|
}, [_c('time-spinner', {
|
|
ref: "maxSpinner",
|
|
attrs: {
|
|
"show-seconds": _vm.showSeconds,
|
|
"hours": _vm.maxHours,
|
|
"minutes": _vm.maxMinutes,
|
|
"seconds": _vm.maxSeconds
|
|
},
|
|
on: {
|
|
"change": _vm.handleMaxChange,
|
|
"select-range": _vm.setMaxSelectionRange
|
|
}
|
|
})], 1)])]), _c('div', {
|
|
staticClass: "el-time-panel__footer"
|
|
}, [_c('button', {
|
|
staticClass: "el-time-panel__btn cancel",
|
|
attrs: {
|
|
"type": "button"
|
|
},
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.handleCancel()
|
|
}
|
|
}
|
|
}, [_vm._v(_vm._s(_vm.t('el.datepicker.cancel')))]), _c('button', {
|
|
staticClass: "el-time-panel__btn confirm",
|
|
attrs: {
|
|
"type": "button",
|
|
"disabled": _vm.btnDisabled
|
|
},
|
|
on: {
|
|
"click": function($event) {
|
|
_vm.handleConfirm()
|
|
}
|
|
}
|
|
}, [_vm._v(_vm._s(_vm.t('el.datepicker.confirm')))])])])])
|
|
},staticRenderFns: []}
|
|
|
|
/***/ }
|
|
|
|
/******/ }); |