first

node_modules/vant/es/datetime-picker/DatePicker.js

@@ -0,0 +1,314 @@
+import _construct from "@babel/runtime/helpers/esm/construct";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { createNamespace } from '../utils';
+import { isDate } from '../utils/validate/date';
+import { padZero } from '../utils/format/string';
+import { getTrueValue, getMonthEndDay } from './utils';
+import { sharedProps, TimePickerMixin } from './shared';
+var currentYear = new Date().getFullYear();
+
+var _createNamespace = createNamespace('date-picker'),
+    createComponent = _createNamespace[0];
+
+export default createComponent({
+  mixins: [TimePickerMixin],
+  props: _extends({}, sharedProps, {
+    type: {
+      type: String,
+      default: 'datetime'
+    },
+    minDate: {
+      type: Date,
+      default: function _default() {
+        return new Date(currentYear - 10, 0, 1);
+      },
+      validator: isDate
+    },
+    maxDate: {
+      type: Date,
+      default: function _default() {
+        return new Date(currentYear + 10, 11, 31);
+      },
+      validator: isDate
+    }
+  }),
+  watch: {
+    filter: 'updateInnerValue',
+    minDate: function minDate() {
+      var _this = this;
+
+      this.$nextTick(function () {
+        _this.updateInnerValue();
+      });
+    },
+    maxDate: function maxDate(value) {
+      if (this.innerValue.valueOf() >= value.valueOf()) {
+        this.innerValue = value;
+      } else {
+        this.updateInnerValue();
+      }
+    },
+    value: function value(val) {
+      val = this.formatValue(val);
+
+      if (val && val.valueOf() !== this.innerValue.valueOf()) {
+        this.innerValue = val;
+      }
+    }
+  },
+  computed: {
+    ranges: function ranges() {
+      var _this$getBoundary = this.getBoundary('max', this.innerValue ? this.innerValue : this.minDate),
+          maxYear = _this$getBoundary.maxYear,
+          maxDate = _this$getBoundary.maxDate,
+          maxMonth = _this$getBoundary.maxMonth,
+          maxHour = _this$getBoundary.maxHour,
+          maxMinute = _this$getBoundary.maxMinute;
+
+      var _this$getBoundary2 = this.getBoundary('min', this.innerValue ? this.innerValue : this.minDate),
+          minYear = _this$getBoundary2.minYear,
+          minDate = _this$getBoundary2.minDate,
+          minMonth = _this$getBoundary2.minMonth,
+          minHour = _this$getBoundary2.minHour,
+          minMinute = _this$getBoundary2.minMinute;
+
+      var result = [{
+        type: 'year',
+        range: [minYear, maxYear]
+      }, {
+        type: 'month',
+        range: [minMonth, maxMonth]
+      }, {
+        type: 'day',
+        range: [minDate, maxDate]
+      }, {
+        type: 'hour',
+        range: [minHour, maxHour]
+      }, {
+        type: 'minute',
+        range: [minMinute, maxMinute]
+      }];
+
+      switch (this.type) {
+        case 'date':
+          result = result.slice(0, 3);
+          break;
+
+        case 'year-month':
+          result = result.slice(0, 2);
+          break;
+
+        case 'month-day':
+          result = result.slice(1, 3);
+          break;
+
+        case 'datehour':
+          result = result.slice(0, 4);
+          break;
+      }
+
+      if (this.columnsOrder) {
+        var columnsOrder = this.columnsOrder.concat(result.map(function (column) {
+          return column.type;
+        }));
+        result.sort(function (a, b) {
+          return columnsOrder.indexOf(a.type) - columnsOrder.indexOf(b.type);
+        });
+      }
+
+      return result;
+    }
+  },
+  methods: {
+    formatValue: function formatValue(value) {
+      var _this2 = this;
+
+      if (!isDate(value)) {
+        return null;
+      }
+
+      var minDate = new Date(this.minDate);
+      var maxDate = new Date(this.maxDate);
+      var dateMethods = {
+        year: 'getFullYear',
+        month: 'getMonth',
+        day: 'getDate',
+        hour: 'getHours',
+        minute: 'getMinutes'
+      };
+
+      if (this.originColumns) {
+        var dateColumns = this.originColumns.map(function (_ref, index) {
+          var type = _ref.type,
+              values = _ref.values;
+          var range = _this2.ranges[index].range;
+          var minDateVal = minDate[dateMethods[type]]();
+          var maxDateVal = maxDate[dateMethods[type]]();
+          var min = type === 'month' ? +values[0] - 1 : +values[0];
+          var max = type === 'month' ? +values[values.length - 1] - 1 : +values[values.length - 1];
+          return {
+            type: type,
+            values: [minDateVal < range[0] ? Math.max(minDateVal, min) : min || minDateVal, maxDateVal > range[1] ? Math.min(maxDateVal, max) : max || maxDateVal]
+          };
+        });
+
+        if (this.type === 'month-day') {
+          var year = (this.innerValue || this.minDate).getFullYear();
+          dateColumns.unshift({
+            type: 'year',
+            values: [year, year]
+          });
+        }
+
+        var dates = Object.keys(dateMethods).map(function (type) {
+          var _dateColumns$filter$;
+
+          return (_dateColumns$filter$ = dateColumns.filter(function (item) {
+            return item.type === type;
+          })[0]) == null ? void 0 : _dateColumns$filter$.values;
+        }).filter(function (item) {
+          return item;
+        });
+        minDate = _construct(Date, dates.map(function (val) {
+          return getTrueValue(val[0]);
+        }));
+        maxDate = _construct(Date, dates.map(function (val) {
+          return getTrueValue(val[1]);
+        }));
+      }
+
+      value = Math.max(value, minDate.getTime());
+      value = Math.min(value, maxDate.getTime());
+      return new Date(value);
+    },
+    getBoundary: function getBoundary(type, value) {
+      var _ref2;
+
+      var boundary = this[type + "Date"];
+      var year = boundary.getFullYear();
+      var month = 1;
+      var date = 1;
+      var hour = 0;
+      var minute = 0;
+
+      if (type === 'max') {
+        month = 12;
+        date = getMonthEndDay(value.getFullYear(), value.getMonth() + 1);
+        hour = 23;
+        minute = 59;
+      }
+
+      if (value.getFullYear() === year) {
+        month = boundary.getMonth() + 1;
+
+        if (value.getMonth() + 1 === month) {
+          date = boundary.getDate();
+
+          if (value.getDate() === date) {
+            hour = boundary.getHours();
+
+            if (value.getHours() === hour) {
+              minute = boundary.getMinutes();
+            }
+          }
+        }
+      }
+
+      return _ref2 = {}, _ref2[type + "Year"] = year, _ref2[type + "Month"] = month, _ref2[type + "Date"] = date, _ref2[type + "Hour"] = hour, _ref2[type + "Minute"] = minute, _ref2;
+    },
+    updateInnerValue: function updateInnerValue() {
+      var _this3 = this;
+
+      var type = this.type;
+      var indexes = this.getPicker().getIndexes();
+
+      var getValue = function getValue(type) {
+        var index = 0;
+
+        _this3.originColumns.forEach(function (column, columnIndex) {
+          if (type === column.type) {
+            index = columnIndex;
+          }
+        });
+
+        var values = _this3.originColumns[index].values;
+        return getTrueValue(values[indexes[index]]);
+      };
+
+      var year;
+      var month;
+      var day;
+
+      if (type === 'month-day') {
+        year = (this.innerValue || this.minDate).getFullYear();
+        month = getValue('month');
+        day = getValue('day');
+      } else {
+        year = getValue('year');
+        month = getValue('month');
+        day = type === 'year-month' ? 1 : getValue('day');
+      }
+
+      var maxDay = getMonthEndDay(year, month);
+      day = day > maxDay ? maxDay : day;
+      var hour = 0;
+      var minute = 0;
+
+      if (type === 'datehour') {
+        hour = getValue('hour');
+      }
+
+      if (type === 'datetime') {
+        hour = getValue('hour');
+        minute = getValue('minute');
+      }
+
+      var value = new Date(year, month - 1, day, hour, minute);
+      this.innerValue = this.formatValue(value);
+    },
+    onChange: function onChange(picker) {
+      var _this4 = this;
+
+      this.updateInnerValue();
+      this.$nextTick(function () {
+        _this4.$nextTick(function () {
+          // https://github.com/vant-ui/vant/issues/9775
+          _this4.updateInnerValue();
+
+          _this4.$emit('change', picker);
+        });
+      });
+    },
+    updateColumnValue: function updateColumnValue() {
+      var _this5 = this;
+
+      var value = this.innerValue ? this.innerValue : this.minDate;
+      var formatter = this.formatter;
+      var values = this.originColumns.map(function (column) {
+        switch (column.type) {
+          case 'year':
+            return formatter('year', "" + value.getFullYear());
+
+          case 'month':
+            return formatter('month', padZero(value.getMonth() + 1));
+
+          case 'day':
+            return formatter('day', padZero(value.getDate()));
+
+          case 'hour':
+            return formatter('hour', padZero(value.getHours()));
+
+          case 'minute':
+            return formatter('minute', padZero(value.getMinutes()));
+
+          default:
+            // no default
+            return null;
+        }
+      });
+      this.$nextTick(function () {
+        _this5.getPicker().setValues(values);
+      });
+    }
+  }
+});

node_modules/vant/es/datetime-picker/TimePicker.js

@@ -0,0 +1,135 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { createNamespace } from '../utils';
+import { padZero } from '../utils/format/string';
+import { range } from '../utils/format/number';
+import { sharedProps, TimePickerMixin } from './shared';
+
+var _createNamespace = createNamespace('time-picker'),
+    createComponent = _createNamespace[0];
+
+export default createComponent({
+  mixins: [TimePickerMixin],
+  props: _extends({}, sharedProps, {
+    minHour: {
+      type: [Number, String],
+      default: 0
+    },
+    maxHour: {
+      type: [Number, String],
+      default: 23
+    },
+    minMinute: {
+      type: [Number, String],
+      default: 0
+    },
+    maxMinute: {
+      type: [Number, String],
+      default: 59
+    }
+  }),
+  computed: {
+    ranges: function ranges() {
+      return [{
+        type: 'hour',
+        range: [+this.minHour, +this.maxHour]
+      }, {
+        type: 'minute',
+        range: [+this.minMinute, +this.maxMinute]
+      }];
+    }
+  },
+  watch: {
+    filter: 'updateInnerValue',
+    minHour: function minHour() {
+      var _this = this;
+
+      this.$nextTick(function () {
+        _this.updateInnerValue();
+      });
+    },
+    maxHour: function maxHour(value) {
+      var _this$innerValue$spli = this.innerValue.split(':'),
+          hour = _this$innerValue$spli[0],
+          minute = _this$innerValue$spli[1];
+
+      if (hour >= value) {
+        this.innerValue = this.formatValue(value + ":" + minute);
+        this.updateColumnValue();
+      } else {
+        this.updateInnerValue();
+      }
+    },
+    minMinute: 'updateInnerValue',
+    maxMinute: function maxMinute(value) {
+      var _this$innerValue$spli2 = this.innerValue.split(':'),
+          hour = _this$innerValue$spli2[0],
+          minute = _this$innerValue$spli2[1];
+
+      if (minute >= value) {
+        this.innerValue = this.formatValue(hour + ":" + value);
+        this.updateColumnValue();
+      } else {
+        this.updateInnerValue();
+      }
+    },
+    value: function value(val) {
+      val = this.formatValue(val);
+
+      if (val !== this.innerValue) {
+        this.innerValue = val;
+        this.updateColumnValue();
+      }
+    }
+  },
+  methods: {
+    formatValue: function formatValue(value) {
+      if (!value) {
+        value = padZero(this.minHour) + ":" + padZero(this.minMinute);
+      }
+
+      var _value$split = value.split(':'),
+          hour = _value$split[0],
+          minute = _value$split[1];
+
+      hour = padZero(range(hour, this.minHour, this.maxHour));
+      minute = padZero(range(minute, this.minMinute, this.maxMinute));
+      return hour + ":" + minute;
+    },
+    updateInnerValue: function updateInnerValue() {
+      var _this$getPicker$getIn = this.getPicker().getIndexes(),
+          hourIndex = _this$getPicker$getIn[0],
+          minuteIndex = _this$getPicker$getIn[1];
+
+      var _this$originColumns = this.originColumns,
+          hourColumn = _this$originColumns[0],
+          minuteColumn = _this$originColumns[1];
+      var hour = hourColumn.values[hourIndex] || hourColumn.values[0];
+      var minute = minuteColumn.values[minuteIndex] || minuteColumn.values[0];
+      this.innerValue = this.formatValue(hour + ":" + minute);
+      this.updateColumnValue();
+    },
+    onChange: function onChange(picker) {
+      var _this2 = this;
+
+      this.updateInnerValue();
+      this.$nextTick(function () {
+        _this2.$nextTick(function () {
+          // https://github.com/vant-ui/vant/issues/9775
+          _this2.updateInnerValue();
+
+          _this2.$emit('change', picker);
+        });
+      });
+    },
+    updateColumnValue: function updateColumnValue() {
+      var _this3 = this;
+
+      var formatter = this.formatter;
+      var pair = this.innerValue.split(':');
+      var values = [formatter('hour', pair[0]), formatter('minute', pair[1])];
+      this.$nextTick(function () {
+        _this3.getPicker().setValues(values);
+      });
+    }
+  }
+});

node_modules/vant/es/datetime-picker/index.js

@@ -0,0 +1,29 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { createNamespace } from '../utils';
+import TimePicker from './TimePicker';
+import DatePicker from './DatePicker';
+
+var _createNamespace = createNamespace('datetime-picker'),
+    createComponent = _createNamespace[0],
+    bem = _createNamespace[1];
+
+export default createComponent({
+  props: _extends({}, TimePicker.props, DatePicker.props),
+  methods: {
+    // @exposed-api
+    getPicker: function getPicker() {
+      return this.$refs.root.getProxiedPicker();
+    }
+  },
+  render: function render() {
+    var h = arguments[0];
+    var Component = this.type === 'time' ? TimePicker : DatePicker;
+    return h(Component, {
+      "ref": "root",
+      "class": bem(),
+      "scopedSlots": this.$scopedSlots,
+      "props": _extends({}, this.$props),
+      "on": _extends({}, this.$listeners)
+    });
+  }
+});

node_modules/vant/es/datetime-picker/shared.js

@@ -0,0 +1,137 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { times } from './utils';
+import { padZero } from '../utils/format/string';
+import { pickerProps } from '../picker/shared';
+import Picker from '../picker';
+export var sharedProps = _extends({}, pickerProps, {
+  value: null,
+  filter: Function,
+  columnsOrder: Array,
+  showToolbar: {
+    type: Boolean,
+    default: true
+  },
+  formatter: {
+    type: Function,
+    default: function _default(type, value) {
+      return value;
+    }
+  }
+});
+export var TimePickerMixin = {
+  data: function data() {
+    return {
+      innerValue: this.formatValue(this.value)
+    };
+  },
+  computed: {
+    originColumns: function originColumns() {
+      var _this = this;
+
+      return this.ranges.map(function (_ref) {
+        var type = _ref.type,
+            rangeArr = _ref.range;
+        var values = times(rangeArr[1] - rangeArr[0] + 1, function (index) {
+          var value = padZero(rangeArr[0] + index);
+          return value;
+        });
+
+        if (_this.filter) {
+          values = _this.filter(type, values);
+        }
+
+        return {
+          type: type,
+          values: values
+        };
+      });
+    },
+    columns: function columns() {
+      var _this2 = this;
+
+      return this.originColumns.map(function (column) {
+        return {
+          values: column.values.map(function (value) {
+            return _this2.formatter(column.type, value);
+          })
+        };
+      });
+    }
+  },
+  watch: {
+    columns: 'updateColumnValue',
+    innerValue: function innerValue(val, oldVal) {
+      if (!oldVal) {
+        this.$emit('input', null);
+      } else {
+        this.$emit('input', val);
+      }
+    }
+  },
+  mounted: function mounted() {
+    var _this3 = this;
+
+    this.updateColumnValue();
+    this.$nextTick(function () {
+      _this3.updateInnerValue();
+    });
+  },
+  methods: {
+    getPicker: function getPicker() {
+      return this.$refs.picker;
+    },
+    // https://github.com/vant-ui/vant/issues/10013
+    getProxiedPicker: function getProxiedPicker() {
+      var _this4 = this;
+
+      var picker = this.$refs.picker;
+
+      if (picker) {
+        var proxy = function proxy(fn) {
+          return function () {
+            picker[fn].apply(picker, arguments);
+
+            _this4.updateInnerValue();
+          };
+        };
+
+        return _extends({}, picker, {
+          setValues: proxy('setValues'),
+          setIndexes: proxy('setIndexes'),
+          setColumnIndex: proxy('setColumnIndex'),
+          setColumnValue: proxy('setColumnValue')
+        });
+      }
+    },
+    onConfirm: function onConfirm() {
+      this.$emit('input', this.innerValue);
+      this.$emit('confirm', this.innerValue);
+    },
+    onCancel: function onCancel() {
+      this.$emit('cancel');
+    }
+  },
+  render: function render() {
+    var _this5 = this;
+
+    var h = arguments[0];
+    var props = {};
+    Object.keys(pickerProps).forEach(function (key) {
+      props[key] = _this5[key];
+    });
+    return h(Picker, {
+      "ref": "picker",
+      "attrs": {
+        "columns": this.columns,
+        "readonly": this.readonly
+      },
+      "scopedSlots": this.$scopedSlots,
+      "on": {
+        "change": this.onChange,
+        "confirm": this.onConfirm,
+        "cancel": this.onCancel
+      },
+      "props": _extends({}, props)
+    });
+  }
+};

node_modules/vant/es/datetime-picker/style/index.js

@@ -0,0 +1,3 @@
+import '../../style/base.css';
+import '../../loading/index.css';
+import '../../picker/index.css';

node_modules/vant/es/datetime-picker/style/less.js

@@ -0,0 +1,3 @@
+import '../../style/base.less';
+import '../../loading/index.less';
+import '../../picker/index.less';

node_modules/vant/es/datetime-picker/utils.js

@@ -0,0 +1,33 @@
+import { isNaN } from '../utils/validate/number';
+export function times(n, iteratee) {
+  if (n < 0) {
+    return [];
+  }
+
+  var index = -1;
+  var result = Array(n);
+
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+
+  return result;
+}
+export function getTrueValue(value) {
+  if (!value) {
+    return 0;
+  }
+
+  while (isNaN(parseInt(value, 10))) {
+    if (value.length > 1) {
+      value = value.slice(1);
+    } else {
+      return 0;
+    }
+  }
+
+  return parseInt(value, 10);
+}
+export function getMonthEndDay(year, month) {
+  return 32 - new Date(year, month - 1, 32).getDate();
+}