build: compile 1.8.7

dist/action-sheet/index.js

@@ -1,70 +1,70 @@
 import { VantComponent } from '../common/component';
 import { button } from '../mixins/button';
 VantComponent({
-  mixins: [button],
+    mixins: [button],
-  props: {
+    props: {
-    show: Boolean,
+        show: Boolean,
-    title: String,
+        title: String,
-    cancelText: String,
+        cancelText: String,
-    description: String,
+        description: String,
-    round: {
+        round: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
+        },
+        zIndex: {
+            type: Number,
+            value: 100,
+        },
+        actions: {
+            type: Array,
+            value: [],
+        },
+        overlay: {
+            type: Boolean,
+            value: true,
+        },
+        closeOnClickOverlay: {
+            type: Boolean,
+            value: true,
+        },
+        closeOnClickAction: {
+            type: Boolean,
+            value: true,
+        },
+        safeAreaInsetBottom: {
+            type: Boolean,
+            value: true,
+        },
     },
-    zIndex: {
+    methods: {
-      type: Number,
+        onSelect(event) {
-      value: 100,
+            const { index } = event.currentTarget.dataset;
+            const { actions, closeOnClickAction, canIUseGetUserProfile } = this.data;
+            const item = actions[index];
+            if (item) {
+                this.$emit('select', item);
+                if (closeOnClickAction) {
+                    this.onClose();
+                }
+                if (item.openType === 'getUserInfo' && canIUseGetUserProfile) {
+                    wx.getUserProfile({
+                        desc: item.getUserProfileDesc || '  ',
+                        complete: (userProfile) => {
+                            this.$emit('getuserinfo', userProfile);
+                        },
+                    });
+                }
+            }
+        },
+        onCancel() {
+            this.$emit('cancel');
+        },
+        onClose() {
+            this.$emit('close');
+        },
+        onClickOverlay() {
+            this.$emit('click-overlay');
+            this.onClose();
+        },
     },
-    actions: {
-      type: Array,
-      value: [],
-    },
-    overlay: {
-      type: Boolean,
-      value: true,
-    },
-    closeOnClickOverlay: {
-      type: Boolean,
-      value: true,
-    },
-    closeOnClickAction: {
-      type: Boolean,
-      value: true,
-    },
-    safeAreaInsetBottom: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  methods: {
-    onSelect(event) {
-      const { index } = event.currentTarget.dataset;
-      const { actions, closeOnClickAction, canIUseGetUserProfile } = this.data;
-      const item = actions[index];
-      if (item) {
-        this.$emit('select', item);
-        if (closeOnClickAction) {
-          this.onClose();
-        }
-        if (item.openType === 'getUserInfo' && canIUseGetUserProfile) {
-          wx.getUserProfile({
-            desc: item.getUserProfileDesc || '  ',
-            complete: (userProfile) => {
-              this.$emit('getuserinfo', userProfile);
-            },
-          });
-        }
-      }
-    },
-    onCancel() {
-      this.$emit('cancel');
-    },
-    onClose() {
-      this.$emit('close');
-    },
-    onClickOverlay() {
-      this.$emit('click-overlay');
-      this.onClose();
-    },
-  },
 });

dist/area/index.js

@@ -3,233 +3,215 @@ import { pickerProps } from '../picker/shared';
 import { requestAnimationFrame } from '../common/utils';
 const EMPTY_CODE = '000000';
 VantComponent({
-  classes: ['active-class', 'toolbar-class', 'column-class'],
+    classes: ['active-class', 'toolbar-class', 'column-class'],
-  props: Object.assign(Object.assign({}, pickerProps), {
+    props: Object.assign(Object.assign({}, pickerProps), { value: {
-    value: {
+            type: String,
-      type: String,
+            observer(value) {
-      observer(value) {
+                this.code = value;
-        this.code = value;
+                this.setValues();
-        this.setValues();
+            },
-      },
+        }, areaList: {
+            type: Object,
+            value: {},
+            observer: 'setValues',
+        }, columnsNum: {
+            type: null,
+            value: 3,
+        }, columnsPlaceholder: {
+            type: Array,
+            observer(val) {
+                this.setData({
+                    typeToColumnsPlaceholder: {
+                        province: val[0] || '',
+                        city: val[1] || '',
+                        county: val[2] || '',
+                    },
+                });
+            },
+        } }),
+    data: {
+        columns: [{ values: [] }, { values: [] }, { values: [] }],
+        typeToColumnsPlaceholder: {},
     },
-    areaList: {
+    mounted() {
-      type: Object,
+        requestAnimationFrame(() => {
-      value: {},
+            this.setValues();
-      observer: 'setValues',
-    },
-    columnsNum: {
-      type: null,
-      value: 3,
-    },
-    columnsPlaceholder: {
-      type: Array,
-      observer(val) {
-        this.setData({
-          typeToColumnsPlaceholder: {
-            province: val[0] || '',
-            city: val[1] || '',
-            county: val[2] || '',
-          },
         });
-      },
     },
-  }),
+    methods: {
-  data: {
+        getPicker() {
-    columns: [{ values: [] }, { values: [] }, { values: [] }],
+            if (this.picker == null) {
-    typeToColumnsPlaceholder: {},
+                this.picker = this.selectComponent('.van-area__picker');
-  },
+            }
-  mounted() {
+            return this.picker;
-    requestAnimationFrame(() => {
+        },
-      this.setValues();
+        onCancel(event) {
-    });
+            this.emit('cancel', event.detail);
-  },
+        },
-  methods: {
+        onConfirm(event) {
-    getPicker() {
+            const { index } = event.detail;
-      if (this.picker == null) {
+            let { value } = event.detail;
-        this.picker = this.selectComponent('.van-area__picker');
+            value = this.parseValues(value);
-      }
+            this.emit('confirm', { value, index });
-      return this.picker;
+        },
-    },
+        emit(type, detail) {
-    onCancel(event) {
+            detail.values = detail.value;
-      this.emit('cancel', event.detail);
+            delete detail.value;
-    },
+            this.$emit(type, detail);
-    onConfirm(event) {
+        },
-      const { index } = event.detail;
+        parseValues(values) {
-      let { value } = event.detail;
+            const { columnsPlaceholder } = this.data;
-      value = this.parseValues(value);
+            return values.map((value, index) => {
-      this.emit('confirm', { value, index });
+                if (value &&
-    },
+                    (!value.code || value.name === columnsPlaceholder[index])) {
-    emit(type, detail) {
+                    return Object.assign(Object.assign({}, value), { code: '', name: '' });
-      detail.values = detail.value;
+                }
-      delete detail.value;
+                return value;
-      this.$emit(type, detail);
-    },
-    parseValues(values) {
-      const { columnsPlaceholder } = this.data;
-      return values.map((value, index) => {
-        if (
-          value &&
-          (!value.code || value.name === columnsPlaceholder[index])
-        ) {
-          return Object.assign(Object.assign({}, value), {
-            code: '',
-            name: '',
-          });
-        }
-        return value;
-      });
-    },
-    onChange(event) {
-      var _a;
-      const { index, picker, value } = event.detail;
-      this.code = value[index].code;
-      (_a = this.setValues()) === null || _a === void 0
-        ? void 0
-        : _a.then(() => {
-            this.$emit('change', {
-              picker,
-              values: this.parseValues(picker.getValues()),
-              index,
             });
-          });
+        },
+        onChange(event) {
+            var _a;
+            const { index, picker, value } = event.detail;
+            this.code = value[index].code;
+            (_a = this.setValues()) === null || _a === void 0 ? void 0 : _a.then(() => {
+                this.$emit('change', {
+                    picker,
+                    values: this.parseValues(picker.getValues()),
+                    index,
+                });
+            });
+        },
+        getConfig(type) {
+            const { areaList } = this.data;
+            return (areaList && areaList[`${type}_list`]) || {};
+        },
+        getList(type, code) {
+            if (type !== 'province' && !code) {
+                return [];
+            }
+            const { typeToColumnsPlaceholder } = this.data;
+            const list = this.getConfig(type);
+            let result = Object.keys(list).map((code) => ({
+                code,
+                name: list[code],
+            }));
+            if (code != null) {
+                // oversea code
+                if (code[0] === '9' && type === 'city') {
+                    code = '9';
+                }
+                result = result.filter((item) => item.code.indexOf(code) === 0);
+            }
+            if (typeToColumnsPlaceholder[type] && result.length) {
+                // set columns placeholder
+                const codeFill = type === 'province'
+                    ? ''
+                    : type === 'city'
+                        ? EMPTY_CODE.slice(2, 4)
+                        : EMPTY_CODE.slice(4, 6);
+                result.unshift({
+                    code: `${code}${codeFill}`,
+                    name: typeToColumnsPlaceholder[type],
+                });
+            }
+            return result;
+        },
+        getIndex(type, code) {
+            let compareNum = type === 'province' ? 2 : type === 'city' ? 4 : 6;
+            const list = this.getList(type, code.slice(0, compareNum - 2));
+            // oversea code
+            if (code[0] === '9' && type === 'province') {
+                compareNum = 1;
+            }
+            code = code.slice(0, compareNum);
+            for (let i = 0; i < list.length; i++) {
+                if (list[i].code.slice(0, compareNum) === code) {
+                    return i;
+                }
+            }
+            return 0;
+        },
+        setValues() {
+            const picker = this.getPicker();
+            if (!picker) {
+                return;
+            }
+            let code = this.code || this.getDefaultCode();
+            const provinceList = this.getList('province');
+            const cityList = this.getList('city', code.slice(0, 2));
+            const stack = [];
+            const indexes = [];
+            const { columnsNum } = this.data;
+            if (columnsNum >= 1) {
+                stack.push(picker.setColumnValues(0, provinceList, false));
+                indexes.push(this.getIndex('province', code));
+            }
+            if (columnsNum >= 2) {
+                stack.push(picker.setColumnValues(1, cityList, false));
+                indexes.push(this.getIndex('city', code));
+                if (cityList.length && code.slice(2, 4) === '00') {
+                    [{ code }] = cityList;
+                }
+            }
+            if (columnsNum === 3) {
+                stack.push(picker.setColumnValues(2, this.getList('county', code.slice(0, 4)), false));
+                indexes.push(this.getIndex('county', code));
+            }
+            return Promise.all(stack)
+                .catch(() => { })
+                .then(() => picker.setIndexes(indexes))
+                .catch(() => { });
+        },
+        getDefaultCode() {
+            const { columnsPlaceholder } = this.data;
+            if (columnsPlaceholder.length) {
+                return EMPTY_CODE;
+            }
+            const countyCodes = Object.keys(this.getConfig('county'));
+            if (countyCodes[0]) {
+                return countyCodes[0];
+            }
+            const cityCodes = Object.keys(this.getConfig('city'));
+            if (cityCodes[0]) {
+                return cityCodes[0];
+            }
+            return '';
+        },
+        getValues() {
+            const picker = this.getPicker();
+            if (!picker) {
+                return [];
+            }
+            return this.parseValues(picker.getValues().filter((value) => !!value));
+        },
+        getDetail() {
+            const values = this.getValues();
+            const area = {
+                code: '',
+                country: '',
+                province: '',
+                city: '',
+                county: '',
+            };
+            if (!values.length) {
+                return area;
+            }
+            const names = values.map((item) => item.name);
+            area.code = values[values.length - 1].code;
+            if (area.code[0] === '9') {
+                area.country = names[1] || '';
+                area.province = names[2] || '';
+            }
+            else {
+                area.province = names[0] || '';
+                area.city = names[1] || '';
+                area.county = names[2] || '';
+            }
+            return area;
+        },
+        reset(code) {
+            this.code = code || '';
+            return this.setValues();
+        },
     },
-    getConfig(type) {
-      const { areaList } = this.data;
-      return (areaList && areaList[`${type}_list`]) || {};
-    },
-    getList(type, code) {
-      if (type !== 'province' && !code) {
-        return [];
-      }
-      const { typeToColumnsPlaceholder } = this.data;
-      const list = this.getConfig(type);
-      let result = Object.keys(list).map((code) => ({
-        code,
-        name: list[code],
-      }));
-      if (code != null) {
-        // oversea code
-        if (code[0] === '9' && type === 'city') {
-          code = '9';
-        }
-        result = result.filter((item) => item.code.indexOf(code) === 0);
-      }
-      if (typeToColumnsPlaceholder[type] && result.length) {
-        // set columns placeholder
-        const codeFill =
-          type === 'province'
-            ? ''
-            : type === 'city'
-            ? EMPTY_CODE.slice(2, 4)
-            : EMPTY_CODE.slice(4, 6);
-        result.unshift({
-          code: `${code}${codeFill}`,
-          name: typeToColumnsPlaceholder[type],
-        });
-      }
-      return result;
-    },
-    getIndex(type, code) {
-      let compareNum = type === 'province' ? 2 : type === 'city' ? 4 : 6;
-      const list = this.getList(type, code.slice(0, compareNum - 2));
-      // oversea code
-      if (code[0] === '9' && type === 'province') {
-        compareNum = 1;
-      }
-      code = code.slice(0, compareNum);
-      for (let i = 0; i < list.length; i++) {
-        if (list[i].code.slice(0, compareNum) === code) {
-          return i;
-        }
-      }
-      return 0;
-    },
-    setValues() {
-      const picker = this.getPicker();
-      if (!picker) {
-        return;
-      }
-      let code = this.code || this.getDefaultCode();
-      const provinceList = this.getList('province');
-      const cityList = this.getList('city', code.slice(0, 2));
-      const stack = [];
-      const indexes = [];
-      const { columnsNum } = this.data;
-      if (columnsNum >= 1) {
-        stack.push(picker.setColumnValues(0, provinceList, false));
-        indexes.push(this.getIndex('province', code));
-      }
-      if (columnsNum >= 2) {
-        stack.push(picker.setColumnValues(1, cityList, false));
-        indexes.push(this.getIndex('city', code));
-        if (cityList.length && code.slice(2, 4) === '00') {
-          [{ code }] = cityList;
-        }
-      }
-      if (columnsNum === 3) {
-        stack.push(
-          picker.setColumnValues(
-            2,
-            this.getList('county', code.slice(0, 4)),
-            false
-          )
-        );
-        indexes.push(this.getIndex('county', code));
-      }
-      return Promise.all(stack)
-        .catch(() => {})
-        .then(() => picker.setIndexes(indexes))
-        .catch(() => {});
-    },
-    getDefaultCode() {
-      const { columnsPlaceholder } = this.data;
-      if (columnsPlaceholder.length) {
-        return EMPTY_CODE;
-      }
-      const countyCodes = Object.keys(this.getConfig('county'));
-      if (countyCodes[0]) {
-        return countyCodes[0];
-      }
-      const cityCodes = Object.keys(this.getConfig('city'));
-      if (cityCodes[0]) {
-        return cityCodes[0];
-      }
-      return '';
-    },
-    getValues() {
-      const picker = this.getPicker();
-      if (!picker) {
-        return [];
-      }
-      return this.parseValues(picker.getValues().filter((value) => !!value));
-    },
-    getDetail() {
-      const values = this.getValues();
-      const area = {
-        code: '',
-        country: '',
-        province: '',
-        city: '',
-        county: '',
-      };
-      if (!values.length) {
-        return area;
-      }
-      const names = values.map((item) => item.name);
-      area.code = values[values.length - 1].code;
-      if (area.code[0] === '9') {
-        area.country = names[1] || '';
-        area.province = names[2] || '';
-      } else {
-        area.province = names[0] || '';
-        area.city = names[1] || '';
-        area.county = names[2] || '';
-      }
-      return area;
-    },
-    reset(code) {
-      this.code = code || '';
-      return this.setValues();
-    },
-  },
 });

dist/button/index.js

@@ -3,67 +3,62 @@ import { button } from '../mixins/button';
 import { canIUseFormFieldButton } from '../common/version';
 const mixins = [button];
 if (canIUseFormFieldButton()) {
-  mixins.push('wx://form-field-button');
+    mixins.push('wx://form-field-button');
 }
 VantComponent({
-  mixins,
+    mixins,
-  classes: ['hover-class', 'loading-class'],
+    classes: ['hover-class', 'loading-class'],
-  data: {
+    data: {
-    baseStyle: '',
+        baseStyle: '',
-  },
-  props: {
-    formType: String,
-    icon: String,
-    classPrefix: {
-      type: String,
-      value: 'van-icon',
     },
-    plain: Boolean,
+    props: {
-    block: Boolean,
+        formType: String,
-    round: Boolean,
+        icon: String,
-    square: Boolean,
+        classPrefix: {
-    loading: Boolean,
+            type: String,
-    hairline: Boolean,
+            value: 'van-icon',
-    disabled: Boolean,
+        },
-    loadingText: String,
+        plain: Boolean,
-    customStyle: String,
+        block: Boolean,
-    loadingType: {
+        round: Boolean,
-      type: String,
+        square: Boolean,
-      value: 'circular',
+        loading: Boolean,
+        hairline: Boolean,
+        disabled: Boolean,
+        loadingText: String,
+        customStyle: String,
+        loadingType: {
+            type: String,
+            value: 'circular',
+        },
+        type: {
+            type: String,
+            value: 'default',
+        },
+        dataset: null,
+        size: {
+            type: String,
+            value: 'normal',
+        },
+        loadingSize: {
+            type: String,
+            value: '20px',
+        },
+        color: String,
     },
-    type: {
+    methods: {
-      type: String,
+        onClick(event) {
-      value: 'default',
+            this.$emit('click', event);
+            const { canIUseGetUserProfile, openType, getUserProfileDesc, lang, } = this.data;
+            if (openType === 'getUserInfo' && canIUseGetUserProfile) {
+                wx.getUserProfile({
+                    desc: getUserProfileDesc || '  ',
+                    lang: lang || 'en',
+                    complete: (userProfile) => {
+                        this.$emit('getuserinfo', userProfile);
+                    },
+                });
+            }
+        },
     },
-    dataset: null,
-    size: {
-      type: String,
-      value: 'normal',
-    },
-    loadingSize: {
-      type: String,
-      value: '20px',
-    },
-    color: String,
-  },
-  methods: {
-    onClick(event) {
-      this.$emit('click', event);
-      const {
-        canIUseGetUserProfile,
-        openType,
-        getUserProfileDesc,
-        lang,
-      } = this.data;
-      if (openType === 'getUserInfo' && canIUseGetUserProfile) {
-        wx.getUserProfile({
-          desc: getUserProfileDesc || '  ',
-          lang: lang || 'en',
-          complete: (userProfile) => {
-            this.$emit('getuserinfo', userProfile);
-          },
-        });
-      }
-    },
-  },
 });

dist/calendar/components/header/index.js

@@ -1,37 +1,37 @@
 import { VantComponent } from '../../../common/component';
 VantComponent({
-  props: {
+    props: {
-    title: {
+        title: {
-      type: String,
+            type: String,
-      value: '日期选择',
+            value: '日期选择',
+        },
+        subtitle: String,
+        showTitle: Boolean,
+        showSubtitle: Boolean,
+        firstDayOfWeek: {
+            type: Number,
+            observer: 'initWeekDay',
+        },
     },
-    subtitle: String,
+    data: {
-    showTitle: Boolean,
+        weekdays: [],
-    showSubtitle: Boolean,
-    firstDayOfWeek: {
-      type: Number,
-      observer: 'initWeekDay',
     },
-  },
+    created() {
-  data: {
+        this.initWeekDay();
-    weekdays: [],
-  },
-  created() {
-    this.initWeekDay();
-  },
-  methods: {
-    initWeekDay() {
-      const defaultWeeks = ['日', '一', '二', '三', '四', '五', '六'];
-      const firstDayOfWeek = this.data.firstDayOfWeek || 0;
-      this.setData({
-        weekdays: [
-          ...defaultWeeks.slice(firstDayOfWeek, 7),
-          ...defaultWeeks.slice(0, firstDayOfWeek),
-        ],
-      });
     },
-    onClickSubtitle(event) {
+    methods: {
-      this.$emit('click-subtitle', event);
+        initWeekDay() {
+            const defaultWeeks = ['日', '一', '二', '三', '四', '五', '六'];
+            const firstDayOfWeek = this.data.firstDayOfWeek || 0;
+            this.setData({
+                weekdays: [
+                    ...defaultWeeks.slice(firstDayOfWeek, 7),
+                    ...defaultWeeks.slice(0, firstDayOfWeek),
+                ],
+            });
+        },
+        onClickSubtitle(event) {
+            this.$emit('click-subtitle', event);
+        },
     },
-  },
 });

dist/calendar/components/month/index.js

@@ -1,163 +1,154 @@
 import { VantComponent } from '../../../common/component';
-import {
+import { getMonthEndDay, compareDay, getPrevDay, getNextDay, } from '../../utils';
-  getMonthEndDay,
-  compareDay,
-  getPrevDay,
-  getNextDay,
-} from '../../utils';
 VantComponent({
-  props: {
+    props: {
-    date: {
+        date: {
-      type: null,
+            type: null,
-      observer: 'setDays',
+            observer: 'setDays',
+        },
+        type: {
+            type: String,
+            observer: 'setDays',
+        },
+        color: String,
+        minDate: {
+            type: null,
+            observer: 'setDays',
+        },
+        maxDate: {
+            type: null,
+            observer: 'setDays',
+        },
+        showMark: Boolean,
+        rowHeight: null,
+        formatter: {
+            type: null,
+            observer: 'setDays',
+        },
+        currentDate: {
+            type: null,
+            observer: 'setDays',
+        },
+        firstDayOfWeek: {
+            type: Number,
+            observer: 'setDays',
+        },
+        allowSameDay: Boolean,
+        showSubtitle: Boolean,
+        showMonthTitle: Boolean,
     },
-    type: {
+    data: {
-      type: String,
+        visible: true,
-      observer: 'setDays',
+        days: [],
     },
-    color: String,
+    methods: {
-    minDate: {
+        onClick(event) {
-      type: null,
+            const { index } = event.currentTarget.dataset;
-      observer: 'setDays',
+            const item = this.data.days[index];
+            if (item.type !== 'disabled') {
+                this.$emit('click', item);
+            }
+        },
+        setDays() {
+            const days = [];
+            const startDate = new Date(this.data.date);
+            const year = startDate.getFullYear();
+            const month = startDate.getMonth();
+            const totalDay = getMonthEndDay(startDate.getFullYear(), startDate.getMonth() + 1);
+            for (let day = 1; day <= totalDay; day++) {
+                const date = new Date(year, month, day);
+                const type = this.getDayType(date);
+                let config = {
+                    date,
+                    type,
+                    text: day,
+                    bottomInfo: this.getBottomInfo(type),
+                };
+                if (this.data.formatter) {
+                    config = this.data.formatter(config);
+                }
+                days.push(config);
+            }
+            this.setData({ days });
+        },
+        getMultipleDayType(day) {
+            const { currentDate } = this.data;
+            if (!Array.isArray(currentDate)) {
+                return '';
+            }
+            const isSelected = (date) => currentDate.some((item) => compareDay(item, date) === 0);
+            if (isSelected(day)) {
+                const prevDay = getPrevDay(day);
+                const nextDay = getNextDay(day);
+                const prevSelected = isSelected(prevDay);
+                const nextSelected = isSelected(nextDay);
+                if (prevSelected && nextSelected) {
+                    return 'multiple-middle';
+                }
+                if (prevSelected) {
+                    return 'end';
+                }
+                return nextSelected ? 'start' : 'multiple-selected';
+            }
+            return '';
+        },
+        getRangeDayType(day) {
+            const { currentDate, allowSameDay } = this.data;
+            if (!Array.isArray(currentDate)) {
+                return '';
+            }
+            const [startDay, endDay] = currentDate;
+            if (!startDay) {
+                return '';
+            }
+            const compareToStart = compareDay(day, startDay);
+            if (!endDay) {
+                return compareToStart === 0 ? 'start' : '';
+            }
+            const compareToEnd = compareDay(day, endDay);
+            if (compareToStart === 0 && compareToEnd === 0 && allowSameDay) {
+                return 'start-end';
+            }
+            if (compareToStart === 0) {
+                return 'start';
+            }
+            if (compareToEnd === 0) {
+                return 'end';
+            }
+            if (compareToStart > 0 && compareToEnd < 0) {
+                return 'middle';
+            }
+            return '';
+        },
+        getDayType(day) {
+            const { type, minDate, maxDate, currentDate } = this.data;
+            if (compareDay(day, minDate) < 0 || compareDay(day, maxDate) > 0) {
+                return 'disabled';
+            }
+            if (type === 'single') {
+                return compareDay(day, currentDate) === 0 ? 'selected' : '';
+            }
+            if (type === 'multiple') {
+                return this.getMultipleDayType(day);
+            }
+            /* istanbul ignore else */
+            if (type === 'range') {
+                return this.getRangeDayType(day);
+            }
+            return '';
+        },
+        getBottomInfo(type) {
+            if (this.data.type === 'range') {
+                if (type === 'start') {
+                    return '开始';
+                }
+                if (type === 'end') {
+                    return '结束';
+                }
+                if (type === 'start-end') {
+                    return '开始/结束';
+                }
+            }
+        },
     },
-    maxDate: {
-      type: null,
-      observer: 'setDays',
-    },
-    showMark: Boolean,
-    rowHeight: null,
-    formatter: {
-      type: null,
-      observer: 'setDays',
-    },
-    currentDate: {
-      type: null,
-      observer: 'setDays',
-    },
-    firstDayOfWeek: {
-      type: Number,
-      observer: 'setDays',
-    },
-    allowSameDay: Boolean,
-    showSubtitle: Boolean,
-    showMonthTitle: Boolean,
-  },
-  data: {
-    visible: true,
-    days: [],
-  },
-  methods: {
-    onClick(event) {
-      const { index } = event.currentTarget.dataset;
-      const item = this.data.days[index];
-      if (item.type !== 'disabled') {
-        this.$emit('click', item);
-      }
-    },
-    setDays() {
-      const days = [];
-      const startDate = new Date(this.data.date);
-      const year = startDate.getFullYear();
-      const month = startDate.getMonth();
-      const totalDay = getMonthEndDay(
-        startDate.getFullYear(),
-        startDate.getMonth() + 1
-      );
-      for (let day = 1; day <= totalDay; day++) {
-        const date = new Date(year, month, day);
-        const type = this.getDayType(date);
-        let config = {
-          date,
-          type,
-          text: day,
-          bottomInfo: this.getBottomInfo(type),
-        };
-        if (this.data.formatter) {
-          config = this.data.formatter(config);
-        }
-        days.push(config);
-      }
-      this.setData({ days });
-    },
-    getMultipleDayType(day) {
-      const { currentDate } = this.data;
-      if (!Array.isArray(currentDate)) {
-        return '';
-      }
-      const isSelected = (date) =>
-        currentDate.some((item) => compareDay(item, date) === 0);
-      if (isSelected(day)) {
-        const prevDay = getPrevDay(day);
-        const nextDay = getNextDay(day);
-        const prevSelected = isSelected(prevDay);
-        const nextSelected = isSelected(nextDay);
-        if (prevSelected && nextSelected) {
-          return 'multiple-middle';
-        }
-        if (prevSelected) {
-          return 'end';
-        }
-        return nextSelected ? 'start' : 'multiple-selected';
-      }
-      return '';
-    },
-    getRangeDayType(day) {
-      const { currentDate, allowSameDay } = this.data;
-      if (!Array.isArray(currentDate)) {
-        return '';
-      }
-      const [startDay, endDay] = currentDate;
-      if (!startDay) {
-        return '';
-      }
-      const compareToStart = compareDay(day, startDay);
-      if (!endDay) {
-        return compareToStart === 0 ? 'start' : '';
-      }
-      const compareToEnd = compareDay(day, endDay);
-      if (compareToStart === 0 && compareToEnd === 0 && allowSameDay) {
-        return 'start-end';
-      }
-      if (compareToStart === 0) {
-        return 'start';
-      }
-      if (compareToEnd === 0) {
-        return 'end';
-      }
-      if (compareToStart > 0 && compareToEnd < 0) {
-        return 'middle';
-      }
-      return '';
-    },
-    getDayType(day) {
-      const { type, minDate, maxDate, currentDate } = this.data;
-      if (compareDay(day, minDate) < 0 || compareDay(day, maxDate) > 0) {
-        return 'disabled';
-      }
-      if (type === 'single') {
-        return compareDay(day, currentDate) === 0 ? 'selected' : '';
-      }
-      if (type === 'multiple') {
-        return this.getMultipleDayType(day);
-      }
-      /* istanbul ignore else */
-      if (type === 'range') {
-        return this.getRangeDayType(day);
-      }
-      return '';
-    },
-    getBottomInfo(type) {
-      if (this.data.type === 'range') {
-        if (type === 'start') {
-          return '开始';
-        }
-        if (type === 'end') {
-          return '结束';
-        }
-        if (type === 'start-end') {
-          return '开始/结束';
-        }
-      }
-    },
-  },
 });

dist/calendar/index.js

@@ -1,348 +1,323 @@
 import { VantComponent } from '../common/component';
-import {
+import { ROW_HEIGHT, getPrevDay, getNextDay, getToday, compareDay, copyDates, calcDateNum, formatMonthTitle, compareMonth, getMonths, getDayByOffset, } from './utils';
-  ROW_HEIGHT,
-  getPrevDay,
-  getNextDay,
-  getToday,
-  compareDay,
-  copyDates,
-  calcDateNum,
-  formatMonthTitle,
-  compareMonth,
-  getMonths,
-  getDayByOffset,
-} from './utils';
 import Toast from '../toast/toast';
 import { requestAnimationFrame } from '../common/utils';
 const initialMinDate = getToday().getTime();
 const initialMaxDate = (() => {
-  const now = getToday();
+    const now = getToday();
-  return new Date(
+    return new Date(now.getFullYear(), now.getMonth() + 6, now.getDate()).getTime();
-    now.getFullYear(),
-    now.getMonth() + 6,
-    now.getDate()
-  ).getTime();
 })();
 VantComponent({
-  props: {
+    props: {
-    title: {
+        title: {
-      type: String,
+            type: String,
-      value: '日期选择',
+            value: '日期选择',
+        },
+        color: String,
+        show: {
+            type: Boolean,
+            observer(val) {
+                if (val) {
+                    this.initRect();
+                    this.scrollIntoView();
+                }
+            },
+        },
+        formatter: null,
+        confirmText: {
+            type: String,
+            value: '确定',
+        },
+        confirmDisabledText: {
+            type: String,
+            value: '确定',
+        },
+        rangePrompt: String,
+        showRangePrompt: {
+            type: Boolean,
+            value: true,
+        },
+        defaultDate: {
+            type: null,
+            observer(val) {
+                this.setData({ currentDate: val });
+                this.scrollIntoView();
+            },
+        },
+        allowSameDay: Boolean,
+        type: {
+            type: String,
+            value: 'single',
+            observer: 'reset',
+        },
+        minDate: {
+            type: Number,
+            value: initialMinDate,
+        },
+        maxDate: {
+            type: Number,
+            value: initialMaxDate,
+        },
+        position: {
+            type: String,
+            value: 'bottom',
+        },
+        rowHeight: {
+            type: null,
+            value: ROW_HEIGHT,
+        },
+        round: {
+            type: Boolean,
+            value: true,
+        },
+        poppable: {
+            type: Boolean,
+            value: true,
+        },
+        showMark: {
+            type: Boolean,
+            value: true,
+        },
+        showTitle: {
+            type: Boolean,
+            value: true,
+        },
+        showConfirm: {
+            type: Boolean,
+            value: true,
+        },
+        showSubtitle: {
+            type: Boolean,
+            value: true,
+        },
+        safeAreaInsetBottom: {
+            type: Boolean,
+            value: true,
+        },
+        closeOnClickOverlay: {
+            type: Boolean,
+            value: true,
+        },
+        maxRange: {
+            type: null,
+            value: null,
+        },
+        firstDayOfWeek: {
+            type: Number,
+            value: 0,
+        },
     },
-    color: String,
+    data: {
-    show: {
+        subtitle: '',
-      type: Boolean,
+        currentDate: null,
-      observer(val) {
+        scrollIntoView: '',
-        if (val) {
-          this.initRect();
-          this.scrollIntoView();
-        }
-      },
     },
-    formatter: null,
+    created() {
-    confirmText: {
+        this.setData({
-      type: String,
+            currentDate: this.getInitialDate(this.data.defaultDate),
-      value: '确定',
-    },
-    confirmDisabledText: {
-      type: String,
-      value: '确定',
-    },
-    rangePrompt: String,
-    showRangePrompt: {
-      type: Boolean,
-      value: true,
-    },
-    defaultDate: {
-      type: null,
-      observer(val) {
-        this.setData({ currentDate: val });
-        this.scrollIntoView();
-      },
-    },
-    allowSameDay: Boolean,
-    type: {
-      type: String,
-      value: 'single',
-      observer: 'reset',
-    },
-    minDate: {
-      type: Number,
-      value: initialMinDate,
-    },
-    maxDate: {
-      type: Number,
-      value: initialMaxDate,
-    },
-    position: {
-      type: String,
-      value: 'bottom',
-    },
-    rowHeight: {
-      type: null,
-      value: ROW_HEIGHT,
-    },
-    round: {
-      type: Boolean,
-      value: true,
-    },
-    poppable: {
-      type: Boolean,
-      value: true,
-    },
-    showMark: {
-      type: Boolean,
-      value: true,
-    },
-    showTitle: {
-      type: Boolean,
-      value: true,
-    },
-    showConfirm: {
-      type: Boolean,
-      value: true,
-    },
-    showSubtitle: {
-      type: Boolean,
-      value: true,
-    },
-    safeAreaInsetBottom: {
-      type: Boolean,
-      value: true,
-    },
-    closeOnClickOverlay: {
-      type: Boolean,
-      value: true,
-    },
-    maxRange: {
-      type: null,
-      value: null,
-    },
-    firstDayOfWeek: {
-      type: Number,
-      value: 0,
-    },
-  },
-  data: {
-    subtitle: '',
-    currentDate: null,
-    scrollIntoView: '',
-  },
-  created() {
-    this.setData({
-      currentDate: this.getInitialDate(this.data.defaultDate),
-    });
-  },
-  mounted() {
-    if (this.data.show || !this.data.poppable) {
-      this.initRect();
-      this.scrollIntoView();
-    }
-  },
-  methods: {
-    reset() {
-      this.setData({ currentDate: this.getInitialDate() });
-      this.scrollIntoView();
-    },
-    initRect() {
-      if (this.contentObserver != null) {
-        this.contentObserver.disconnect();
-      }
-      const contentObserver = this.createIntersectionObserver({
-        thresholds: [0, 0.1, 0.9, 1],
-        observeAll: true,
-      });
-      this.contentObserver = contentObserver;
-      contentObserver.relativeTo('.van-calendar__body');
-      contentObserver.observe('.month', (res) => {
-        if (res.boundingClientRect.top <= res.relativeRect.top) {
-          // @ts-ignore
-          this.setData({ subtitle: formatMonthTitle(res.dataset.date) });
-        }
-      });
-    },
-    limitDateRange(date, minDate = null, maxDate = null) {
-      minDate = minDate || this.data.minDate;
-      maxDate = maxDate || this.data.maxDate;
-      if (compareDay(date, minDate) === -1) {
-        return minDate;
-      }
-      if (compareDay(date, maxDate) === 1) {
-        return maxDate;
-      }
-      return date;
-    },
-    getInitialDate(defaultDate = null) {
-      const { type, minDate, maxDate } = this.data;
-      const now = getToday().getTime();
-      if (type === 'range') {
-        if (!Array.isArray(defaultDate)) {
-          defaultDate = [];
-        }
-        const [startDay, endDay] = defaultDate || [];
-        const start = this.limitDateRange(
-          startDay || now,
-          minDate,
-          getPrevDay(new Date(maxDate)).getTime()
-        );
-        const end = this.limitDateRange(
-          endDay || now,
-          getNextDay(new Date(minDate)).getTime()
-        );
-        return [start, end];
-      }
-      if (type === 'multiple') {
-        if (Array.isArray(defaultDate)) {
-          return defaultDate.map((date) => this.limitDateRange(date));
-        }
-        return [this.limitDateRange(now)];
-      }
-      if (!defaultDate || Array.isArray(defaultDate)) {
-        defaultDate = now;
-      }
-      return this.limitDateRange(defaultDate);
-    },
-    scrollIntoView() {
-      requestAnimationFrame(() => {
-        const {
-          currentDate,
-          type,
-          show,
-          poppable,
-          minDate,
-          maxDate,
-        } = this.data;
-        // @ts-ignore
-        const targetDate = type === 'single' ? currentDate : currentDate[0];
-        const displayed = show || !poppable;
-        if (!targetDate || !displayed) {
-          return;
-        }
-        const months = getMonths(minDate, maxDate);
-        months.some((month, index) => {
-          if (compareMonth(month, targetDate) === 0) {
-            this.setData({ scrollIntoView: `month${index}` });
-            return true;
-          }
-          return false;
         });
-      });
     },
-    onOpen() {
+    mounted() {
-      this.$emit('open');
+        if (this.data.show || !this.data.poppable) {
-    },
+            this.initRect();
-    onOpened() {
+            this.scrollIntoView();
-      this.$emit('opened');
-    },
-    onClose() {
-      this.$emit('close');
-    },
-    onClosed() {
-      this.$emit('closed');
-    },
-    onClickDay(event) {
-      const { date } = event.detail;
-      const { type, currentDate, allowSameDay } = this.data;
-      if (type === 'range') {
-        // @ts-ignore
-        const [startDay, endDay] = currentDate;
-        if (startDay && !endDay) {
-          const compareToStart = compareDay(date, startDay);
-          if (compareToStart === 1) {
-            this.select([startDay, date], true);
-          } else if (compareToStart === -1) {
-            this.select([date, null]);
-          } else if (allowSameDay) {
-            this.select([date, date]);
-          }
-        } else {
-          this.select([date, null]);
         }
-      } else if (type === 'multiple') {
-        let selectedIndex;
-        // @ts-ignore
-        const selected = currentDate.some((dateItem, index) => {
-          const equal = compareDay(dateItem, date) === 0;
-          if (equal) {
-            selectedIndex = index;
-          }
-          return equal;
-        });
-        if (selected) {
-          // @ts-ignore
-          const cancelDate = currentDate.splice(selectedIndex, 1);
-          this.setData({ currentDate });
-          this.unselect(cancelDate);
-        } else {
-          // @ts-ignore
-          this.select([...currentDate, date]);
-        }
-      } else {
-        this.select(date, true);
-      }
     },
-    unselect(dateArray) {
+    methods: {
-      const date = dateArray[0];
+        reset() {
-      if (date) {
+            this.setData({ currentDate: this.getInitialDate() });
-        this.$emit('unselect', copyDates(date));
+            this.scrollIntoView();
-      }
+        },
-    },
+        initRect() {
-    select(date, complete) {
+            if (this.contentObserver != null) {
-      if (complete && this.data.type === 'range') {
+                this.contentObserver.disconnect();
-        const valid = this.checkRange(date);
+            }
-        if (!valid) {
+            const contentObserver = this.createIntersectionObserver({
-          // auto selected to max range if showConfirm
+                thresholds: [0, 0.1, 0.9, 1],
-          if (this.data.showConfirm) {
+                observeAll: true,
-            this.emit([
+            });
-              date[0],
+            this.contentObserver = contentObserver;
-              getDayByOffset(date[0], this.data.maxRange - 1),
+            contentObserver.relativeTo('.van-calendar__body');
-            ]);
+            contentObserver.observe('.month', (res) => {
-          } else {
+                if (res.boundingClientRect.top <= res.relativeRect.top) {
+                    // @ts-ignore
+                    this.setData({ subtitle: formatMonthTitle(res.dataset.date) });
+                }
+            });
+        },
+        limitDateRange(date, minDate = null, maxDate = null) {
+            minDate = minDate || this.data.minDate;
+            maxDate = maxDate || this.data.maxDate;
+            if (compareDay(date, minDate) === -1) {
+                return minDate;
+            }
+            if (compareDay(date, maxDate) === 1) {
+                return maxDate;
+            }
+            return date;
+        },
+        getInitialDate(defaultDate = null) {
+            const { type, minDate, maxDate } = this.data;
+            const now = getToday().getTime();
+            if (type === 'range') {
+                if (!Array.isArray(defaultDate)) {
+                    defaultDate = [];
+                }
+                const [startDay, endDay] = defaultDate || [];
+                const start = this.limitDateRange(startDay || now, minDate, getPrevDay(new Date(maxDate)).getTime());
+                const end = this.limitDateRange(endDay || now, getNextDay(new Date(minDate)).getTime());
+                return [start, end];
+            }
+            if (type === 'multiple') {
+                if (Array.isArray(defaultDate)) {
+                    return defaultDate.map((date) => this.limitDateRange(date));
+                }
+                return [this.limitDateRange(now)];
+            }
+            if (!defaultDate || Array.isArray(defaultDate)) {
+                defaultDate = now;
+            }
+            return this.limitDateRange(defaultDate);
+        },
+        scrollIntoView() {
+            requestAnimationFrame(() => {
+                const { currentDate, type, show, poppable, minDate, maxDate, } = this.data;
+                // @ts-ignore
+                const targetDate = type === 'single' ? currentDate : currentDate[0];
+                const displayed = show || !poppable;
+                if (!targetDate || !displayed) {
+                    return;
+                }
+                const months = getMonths(minDate, maxDate);
+                months.some((month, index) => {
+                    if (compareMonth(month, targetDate) === 0) {
+                        this.setData({ scrollIntoView: `month${index}` });
+                        return true;
+                    }
+                    return false;
+                });
+            });
+        },
+        onOpen() {
+            this.$emit('open');
+        },
+        onOpened() {
+            this.$emit('opened');
+        },
+        onClose() {
+            this.$emit('close');
+        },
+        onClosed() {
+            this.$emit('closed');
+        },
+        onClickDay(event) {
+            const { date } = event.detail;
+            const { type, currentDate, allowSameDay } = this.data;
+            if (type === 'range') {
+                // @ts-ignore
+                const [startDay, endDay] = currentDate;
+                if (startDay && !endDay) {
+                    const compareToStart = compareDay(date, startDay);
+                    if (compareToStart === 1) {
+                        this.select([startDay, date], true);
+                    }
+                    else if (compareToStart === -1) {
+                        this.select([date, null]);
+                    }
+                    else if (allowSameDay) {
+                        this.select([date, date]);
+                    }
+                }
+                else {
+                    this.select([date, null]);
+                }
+            }
+            else if (type === 'multiple') {
+                let selectedIndex;
+                // @ts-ignore
+                const selected = currentDate.some((dateItem, index) => {
+                    const equal = compareDay(dateItem, date) === 0;
+                    if (equal) {
+                        selectedIndex = index;
+                    }
+                    return equal;
+                });
+                if (selected) {
+                    // @ts-ignore
+                    const cancelDate = currentDate.splice(selectedIndex, 1);
+                    this.setData({ currentDate });
+                    this.unselect(cancelDate);
+                }
+                else {
+                    // @ts-ignore
+                    this.select([...currentDate, date]);
+                }
+            }
+            else {
+                this.select(date, true);
+            }
+        },
+        unselect(dateArray) {
+            const date = dateArray[0];
+            if (date) {
+                this.$emit('unselect', copyDates(date));
+            }
+        },
+        select(date, complete) {
+            if (complete && this.data.type === 'range') {
+                const valid = this.checkRange(date);
+                if (!valid) {
+                    // auto selected to max range if showConfirm
+                    if (this.data.showConfirm) {
+                        this.emit([
+                            date[0],
+                            getDayByOffset(date[0], this.data.maxRange - 1),
+                        ]);
+                    }
+                    else {
+                        this.emit(date);
+                    }
+                    return;
+                }
+            }
             this.emit(date);
-          }
+            if (complete && !this.data.showConfirm) {
-          return;
+                this.onConfirm();
-        }
+            }
-      }
+        },
-      this.emit(date);
+        emit(date) {
-      if (complete && !this.data.showConfirm) {
+            const getTime = (date) => date instanceof Date ? date.getTime() : date;
-        this.onConfirm();
+            this.setData({
-      }
+                currentDate: Array.isArray(date) ? date.map(getTime) : getTime(date),
+            });
+            this.$emit('select', copyDates(date));
+        },
+        checkRange(date) {
+            const { maxRange, rangePrompt, showRangePrompt } = this.data;
+            if (maxRange && calcDateNum(date) > maxRange) {
+                if (showRangePrompt) {
+                    Toast({
+                        context: this,
+                        message: rangePrompt || `选择天数不能超过 ${maxRange} 天`,
+                    });
+                }
+                this.$emit('over-range');
+                return false;
+            }
+            return true;
+        },
+        onConfirm() {
+            if (this.data.type === 'range' &&
+                !this.checkRange(this.data.currentDate)) {
+                return;
+            }
+            wx.nextTick(() => {
+                // @ts-ignore
+                this.$emit('confirm', copyDates(this.data.currentDate));
+            });
+        },
+        onClickSubtitle(event) {
+            this.$emit('click-subtitle', event);
+        },
     },
-    emit(date) {
-      const getTime = (date) => (date instanceof Date ? date.getTime() : date);
-      this.setData({
-        currentDate: Array.isArray(date) ? date.map(getTime) : getTime(date),
-      });
-      this.$emit('select', copyDates(date));
-    },
-    checkRange(date) {
-      const { maxRange, rangePrompt, showRangePrompt } = this.data;
-      if (maxRange && calcDateNum(date) > maxRange) {
-        if (showRangePrompt) {
-          Toast({
-            context: this,
-            message: rangePrompt || `选择天数不能超过 ${maxRange} 天`,
-          });
-        }
-        this.$emit('over-range');
-        return false;
-      }
-      return true;
-    },
-    onConfirm() {
-      if (
-        this.data.type === 'range' &&
-        !this.checkRange(this.data.currentDate)
-      ) {
-        return;
-      }
-      wx.nextTick(() => {
-        // @ts-ignore
-        this.$emit('confirm', copyDates(this.data.currentDate));
-      });
-    },
-    onClickSubtitle(event) {
-      this.$emit('click-subtitle', event);
-    },
-  },
 });

dist/calendar/utils.d.ts

@@ -1,13 +1,7 @@
 export declare const ROW_HEIGHT = 64;
 export declare function formatMonthTitle(date: Date): string;
-export declare function compareMonth(
+export declare function compareMonth(date1: Date | number, date2: Date | number): 1 | -1 | 0;
-  date1: Date | number,
+export declare function compareDay(day1: Date | number, day2: Date | number): 1 | -1 | 0;
-  date2: Date | number
-): 1 | -1 | 0;
-export declare function compareDay(
-  day1: Date | number,
-  day2: Date | number
-): 1 | -1 | 0;
 export declare function getDayByOffset(date: Date, offset: number): Date;
 export declare function getPrevDay(date: Date): Date;
 export declare function getNextDay(date: Date): Date;

dist/calendar/utils.js

@@ -1,83 +1,83 @@
 export const ROW_HEIGHT = 64;
 export function formatMonthTitle(date) {
-  if (!(date instanceof Date)) {
+    if (!(date instanceof Date)) {
-    date = new Date(date);
+        date = new Date(date);
-  }
+    }
-  return `${date.getFullYear()}年${date.getMonth() + 1}月`;
+    return `${date.getFullYear()}年${date.getMonth() + 1}月`;
 }
 export function compareMonth(date1, date2) {
-  if (!(date1 instanceof Date)) {
+    if (!(date1 instanceof Date)) {
-    date1 = new Date(date1);
+        date1 = new Date(date1);
-  }
+    }
-  if (!(date2 instanceof Date)) {
+    if (!(date2 instanceof Date)) {
-    date2 = new Date(date2);
+        date2 = new Date(date2);
-  }
+    }
-  const year1 = date1.getFullYear();
+    const year1 = date1.getFullYear();
-  const year2 = date2.getFullYear();
+    const year2 = date2.getFullYear();
-  const month1 = date1.getMonth();
+    const month1 = date1.getMonth();
-  const month2 = date2.getMonth();
+    const month2 = date2.getMonth();
-  if (year1 === year2) {
+    if (year1 === year2) {
-    return month1 === month2 ? 0 : month1 > month2 ? 1 : -1;
+        return month1 === month2 ? 0 : month1 > month2 ? 1 : -1;
-  }
+    }
-  return year1 > year2 ? 1 : -1;
+    return year1 > year2 ? 1 : -1;
 }
 export function compareDay(day1, day2) {
-  if (!(day1 instanceof Date)) {
+    if (!(day1 instanceof Date)) {
-    day1 = new Date(day1);
+        day1 = new Date(day1);
-  }
+    }
-  if (!(day2 instanceof Date)) {
+    if (!(day2 instanceof Date)) {
-    day2 = new Date(day2);
+        day2 = new Date(day2);
-  }
+    }
-  const compareMonthResult = compareMonth(day1, day2);
+    const compareMonthResult = compareMonth(day1, day2);
-  if (compareMonthResult === 0) {
+    if (compareMonthResult === 0) {
-    const date1 = day1.getDate();
+        const date1 = day1.getDate();
-    const date2 = day2.getDate();
+        const date2 = day2.getDate();
-    return date1 === date2 ? 0 : date1 > date2 ? 1 : -1;
+        return date1 === date2 ? 0 : date1 > date2 ? 1 : -1;
-  }
+    }
-  return compareMonthResult;
+    return compareMonthResult;
 }
 export function getDayByOffset(date, offset) {
-  date = new Date(date);
+    date = new Date(date);
-  date.setDate(date.getDate() + offset);
+    date.setDate(date.getDate() + offset);
-  return date;
+    return date;
 }
 export function getPrevDay(date) {
-  return getDayByOffset(date, -1);
+    return getDayByOffset(date, -1);
 }
 export function getNextDay(date) {
-  return getDayByOffset(date, 1);
+    return getDayByOffset(date, 1);
 }
 export function getToday() {
-  const today = new Date();
+    const today = new Date();
-  today.setHours(0, 0, 0, 0);
+    today.setHours(0, 0, 0, 0);
-  return today;
+    return today;
 }
 export function calcDateNum(date) {
-  const day1 = new Date(date[0]).getTime();
+    const day1 = new Date(date[0]).getTime();
-  const day2 = new Date(date[1]).getTime();
+    const day2 = new Date(date[1]).getTime();
-  return (day2 - day1) / (1000 * 60 * 60 * 24) + 1;
+    return (day2 - day1) / (1000 * 60 * 60 * 24) + 1;
 }
 export function copyDates(dates) {
-  if (Array.isArray(dates)) {
+    if (Array.isArray(dates)) {
-    return dates.map((date) => {
+        return dates.map((date) => {
-      if (date === null) {
+            if (date === null) {
-        return date;
+                return date;
-      }
+            }
-      return new Date(date);
+            return new Date(date);
-    });
+        });
-  }
+    }
-  return new Date(dates);
+    return new Date(dates);
 }
 export function getMonthEndDay(year, month) {
-  return 32 - new Date(year, month - 1, 32).getDate();
+    return 32 - new Date(year, month - 1, 32).getDate();
 }
 export function getMonths(minDate, maxDate) {
-  const months = [];
+    const months = [];
-  const cursor = new Date(minDate);
+    const cursor = new Date(minDate);
-  cursor.setDate(1);
+    cursor.setDate(1);
-  do {
+    do {
-    months.push(cursor.getTime());
+        months.push(cursor.getTime());
-    cursor.setMonth(cursor.getMonth() + 1);
+        cursor.setMonth(cursor.getMonth() + 1);
-  } while (compareMonth(cursor, maxDate) !== 1);
+    } while (compareMonth(cursor, maxDate) !== 1);
-  return months;
+    return months;
 }

dist/card/index.js

@@ -1,49 +1,49 @@
 import { link } from '../mixins/link';
 import { VantComponent } from '../common/component';
 VantComponent({
-  classes: [
+    classes: [
-    'num-class',
+        'num-class',
-    'desc-class',
+        'desc-class',
-    'thumb-class',
+        'thumb-class',
-    'title-class',
+        'title-class',
-    'price-class',
+        'price-class',
-    'origin-price-class',
+        'origin-price-class',
-  ],
+    ],
-  mixins: [link],
+    mixins: [link],
-  props: {
+    props: {
-    tag: String,
+        tag: String,
-    num: String,
+        num: String,
-    desc: String,
+        desc: String,
-    thumb: String,
+        thumb: String,
-    title: String,
+        title: String,
-    price: {
+        price: {
-      type: String,
+            type: String,
-      observer: 'updatePrice',
+            observer: 'updatePrice',
+        },
+        centered: Boolean,
+        lazyLoad: Boolean,
+        thumbLink: String,
+        originPrice: String,
+        thumbMode: {
+            type: String,
+            value: 'aspectFit',
+        },
+        currency: {
+            type: String,
+            value: '¥',
+        },
     },
-    centered: Boolean,
+    methods: {
-    lazyLoad: Boolean,
+        updatePrice() {
-    thumbLink: String,
+            const { price } = this.data;
-    originPrice: String,
+            const priceArr = price.toString().split('.');
-    thumbMode: {
+            this.setData({
-      type: String,
+                integerStr: priceArr[0],
-      value: 'aspectFit',
+                decimalStr: priceArr[1] ? `.${priceArr[1]}` : '',
+            });
+        },
+        onClickThumb() {
+            this.jumpLink('thumbLink');
+        },
     },
-    currency: {
-      type: String,
-      value: '¥',
-    },
-  },
-  methods: {
-    updatePrice() {
-      const { price } = this.data;
-      const priceArr = price.toString().split('.');
-      this.setData({
-        integerStr: priceArr[0],
-        decimalStr: priceArr[1] ? `.${priceArr[1]}` : '',
-      });
-    },
-    onClickThumb() {
-      this.jumpLink('thumbLink');
-    },
-  },
 });

dist/cell-group/index.js

@@ -1,11 +1,11 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    title: String,
+        title: String,
-    border: {
+        border: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
+        },
+        inset: Boolean,
     },
-    inset: Boolean,
-  },
 });

dist/cell/index.js

@@ -1,38 +1,38 @@
 import { link } from '../mixins/link';
 import { VantComponent } from '../common/component';
 VantComponent({
-  classes: [
+    classes: [
-    'title-class',
+        'title-class',
-    'label-class',
+        'label-class',
-    'value-class',
+        'value-class',
-    'right-icon-class',
+        'right-icon-class',
-    'hover-class',
+        'hover-class',
-  ],
+    ],
-  mixins: [link],
+    mixins: [link],
-  props: {
+    props: {
-    title: null,
+        title: null,
-    value: null,
+        value: null,
-    icon: String,
+        icon: String,
-    size: String,
+        size: String,
-    label: String,
+        label: String,
-    center: Boolean,
+        center: Boolean,
-    isLink: Boolean,
+        isLink: Boolean,
-    required: Boolean,
+        required: Boolean,
-    clickable: Boolean,
+        clickable: Boolean,
-    titleWidth: String,
+        titleWidth: String,
-    customStyle: String,
+        customStyle: String,
-    arrowDirection: String,
+        arrowDirection: String,
-    useLabelSlot: Boolean,
+        useLabelSlot: Boolean,
-    border: {
+        border: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
+        },
+        titleStyle: String,
     },
-    titleStyle: String,
+    methods: {
-  },
+        onClick(event) {
-  methods: {
+            this.$emit('click', event.detail);
-    onClick(event) {
+            this.jumpLink();
-      this.$emit('click', event.detail);
+        },
-      this.jumpLink();
     },
-  },
 });

dist/checkbox-group/index.js

@@ -1,36 +1,36 @@
 import { useChildren } from '../common/relation';
 import { VantComponent } from '../common/component';
 VantComponent({
-  field: true,
+    field: true,
-  relation: useChildren('checkbox', function (target) {
+    relation: useChildren('checkbox', function (target) {
-    this.updateChild(target);
+        this.updateChild(target);
-  }),
+    }),
-  props: {
+    props: {
-    max: Number,
+        max: Number,
-    value: {
+        value: {
-      type: Array,
+            type: Array,
-      observer: 'updateChildren',
+            observer: 'updateChildren',
+        },
+        disabled: {
+            type: Boolean,
+            observer: 'updateChildren',
+        },
+        direction: {
+            type: String,
+            value: 'vertical',
+        },
     },
-    disabled: {
+    methods: {
-      type: Boolean,
+        updateChildren() {
-      observer: 'updateChildren',
+            this.children.forEach((child) => this.updateChild(child));
+        },
+        updateChild(child) {
+            const { value, disabled, direction } = this.data;
+            child.setData({
+                value: value.indexOf(child.data.name) !== -1,
+                parentDisabled: disabled,
+                direction,
+            });
+        },
     },
-    direction: {
-      type: String,
-      value: 'vertical',
-    },
-  },
-  methods: {
-    updateChildren() {
-      this.children.forEach((child) => this.updateChild(child));
-    },
-    updateChild(child) {
-      const { value, disabled, direction } = this.data;
-      child.setData({
-        value: value.indexOf(child.data.name) !== -1,
-        parentDisabled: disabled,
-        direction,
-      });
-    },
-  },
 });

dist/checkbox/index.js

@@ -1,75 +1,77 @@
 import { useParent } from '../common/relation';
 import { VantComponent } from '../common/component';
 function emit(target, value) {
-  target.$emit('input', value);
+    target.$emit('input', value);
-  target.$emit('change', value);
+    target.$emit('change', value);
 }
 VantComponent({
-  field: true,
+    field: true,
-  relation: useParent('checkbox-group'),
+    relation: useParent('checkbox-group'),
-  classes: ['icon-class', 'label-class'],
+    classes: ['icon-class', 'label-class'],
-  props: {
+    props: {
-    value: Boolean,
+        value: Boolean,
-    disabled: Boolean,
+        disabled: Boolean,
-    useIconSlot: Boolean,
+        useIconSlot: Boolean,
-    checkedColor: String,
+        checkedColor: String,
-    labelPosition: {
+        labelPosition: {
-      type: String,
+            type: String,
-      value: 'right',
+            value: 'right',
+        },
+        labelDisabled: Boolean,
+        shape: {
+            type: String,
+            value: 'round',
+        },
+        iconSize: {
+            type: null,
+            value: 20,
+        },
     },
-    labelDisabled: Boolean,
+    data: {
-    shape: {
+        parentDisabled: false,
-      type: String,
+        direction: 'vertical',
-      value: 'round',
     },
-    iconSize: {
+    methods: {
-      type: null,
+        emitChange(value) {
-      value: 20,
+            if (this.parent) {
+                this.setParentValue(this.parent, value);
+            }
+            else {
+                emit(this, value);
+            }
+        },
+        toggle() {
+            const { parentDisabled, disabled, value } = this.data;
+            if (!disabled && !parentDisabled) {
+                this.emitChange(!value);
+            }
+        },
+        onClickLabel() {
+            const { labelDisabled, parentDisabled, disabled, value } = this.data;
+            if (!disabled && !labelDisabled && !parentDisabled) {
+                this.emitChange(!value);
+            }
+        },
+        setParentValue(parent, value) {
+            const parentValue = parent.data.value.slice();
+            const { name } = this.data;
+            const { max } = parent.data;
+            if (value) {
+                if (max && parentValue.length >= max) {
+                    return;
+                }
+                if (parentValue.indexOf(name) === -1) {
+                    parentValue.push(name);
+                    emit(parent, parentValue);
+                }
+            }
+            else {
+                const index = parentValue.indexOf(name);
+                if (index !== -1) {
+                    parentValue.splice(index, 1);
+                    emit(parent, parentValue);
+                }
+            }
+        },
     },
-  },
-  data: {
-    parentDisabled: false,
-    direction: 'vertical',
-  },
-  methods: {
-    emitChange(value) {
-      if (this.parent) {
-        this.setParentValue(this.parent, value);
-      } else {
-        emit(this, value);
-      }
-    },
-    toggle() {
-      const { parentDisabled, disabled, value } = this.data;
-      if (!disabled && !parentDisabled) {
-        this.emitChange(!value);
-      }
-    },
-    onClickLabel() {
-      const { labelDisabled, parentDisabled, disabled, value } = this.data;
-      if (!disabled && !labelDisabled && !parentDisabled) {
-        this.emitChange(!value);
-      }
-    },
-    setParentValue(parent, value) {
-      const parentValue = parent.data.value.slice();
-      const { name } = this.data;
-      const { max } = parent.data;
-      if (value) {
-        if (max && parentValue.length >= max) {
-          return;
-        }
-        if (parentValue.indexOf(name) === -1) {
-          parentValue.push(name);
-          emit(parent, parentValue);
-        }
-      } else {
-        const index = parentValue.indexOf(name);
-        if (index !== -1) {
-          parentValue.splice(index, 1);
-          emit(parent, parentValue);
-        }
-      }
-    },
-  },
 });

dist/circle/canvas.d.ts

@@ -1,6 +1,4 @@
 /// <reference types="miniprogram-api-typings" />
 declare type CanvasContext = WechatMiniprogram.CanvasContext;
-export declare function adaptor(
+export declare function adaptor(ctx: CanvasContext & Record<string, unknown>): CanvasContext;
-  ctx: CanvasContext & Record<string, unknown>
-): CanvasContext;
 export {};

dist/circle/canvas.js

@@ -1,43 +1,43 @@
 export function adaptor(ctx) {
-  // @ts-ignore
+    // @ts-ignore
-  return Object.assign(ctx, {
+    return Object.assign(ctx, {
-    setStrokeStyle(val) {
+        setStrokeStyle(val) {
-      ctx.strokeStyle = val;
+            ctx.strokeStyle = val;
-    },
+        },
-    setLineWidth(val) {
+        setLineWidth(val) {
-      ctx.lineWidth = val;
+            ctx.lineWidth = val;
-    },
+        },
-    setLineCap(val) {
+        setLineCap(val) {
-      ctx.lineCap = val;
+            ctx.lineCap = val;
-    },
+        },
-    setFillStyle(val) {
+        setFillStyle(val) {
-      ctx.fillStyle = val;
+            ctx.fillStyle = val;
-    },
+        },
-    setFontSize(val) {
+        setFontSize(val) {
-      ctx.font = String(val);
+            ctx.font = String(val);
-    },
+        },
-    setGlobalAlpha(val) {
+        setGlobalAlpha(val) {
-      ctx.globalAlpha = val;
+            ctx.globalAlpha = val;
-    },
+        },
-    setLineJoin(val) {
+        setLineJoin(val) {
-      ctx.lineJoin = val;
+            ctx.lineJoin = val;
-    },
+        },
-    setTextAlign(val) {
+        setTextAlign(val) {
-      ctx.textAlign = val;
+            ctx.textAlign = val;
-    },
+        },
-    setMiterLimit(val) {
+        setMiterLimit(val) {
-      ctx.miterLimit = val;
+            ctx.miterLimit = val;
-    },
+        },
-    setShadow(offsetX, offsetY, blur, color) {
+        setShadow(offsetX, offsetY, blur, color) {
-      ctx.shadowOffsetX = offsetX;
+            ctx.shadowOffsetX = offsetX;
-      ctx.shadowOffsetY = offsetY;
+            ctx.shadowOffsetY = offsetY;
-      ctx.shadowBlur = blur;
+            ctx.shadowBlur = blur;
-      ctx.shadowColor = color;
+            ctx.shadowColor = color;
-    },
+        },
-    setTextBaseline(val) {
+        setTextBaseline(val) {
-      ctx.textBaseline = val;
+            ctx.textBaseline = val;
-    },
+        },
-    createCircularGradient() {},
+        createCircularGradient() { },
-    draw() {},
+        draw() { },
-  });
+    });
 }

dist/circle/index.js

@@ -5,188 +5,189 @@ import { isObj } from '../common/validator';
 import { canIUseCanvas2d } from '../common/version';
 import { adaptor } from './canvas';
 function format(rate) {
-  return Math.min(Math.max(rate, 0), 100);
+    return Math.min(Math.max(rate, 0), 100);
 }
 const PERIMETER = 2 * Math.PI;
 const BEGIN_ANGLE = -Math.PI / 2;
 const STEP = 1;
 VantComponent({
-  props: {
+    props: {
-    text: String,
+        text: String,
-    lineCap: {
+        lineCap: {
-      type: String,
+            type: String,
-      value: 'round',
+            value: 'round',
+        },
+        value: {
+            type: Number,
+            value: 0,
+            observer: 'reRender',
+        },
+        speed: {
+            type: Number,
+            value: 50,
+        },
+        size: {
+            type: Number,
+            value: 100,
+            observer() {
+                this.drawCircle(this.currentValue);
+            },
+        },
+        fill: String,
+        layerColor: {
+            type: String,
+            value: WHITE,
+        },
+        color: {
+            type: null,
+            value: BLUE,
+            observer() {
+                this.setHoverColor().then(() => {
+                    this.drawCircle(this.currentValue);
+                });
+            },
+        },
+        type: {
+            type: String,
+            value: '',
+        },
+        strokeWidth: {
+            type: Number,
+            value: 4,
+        },
+        clockwise: {
+            type: Boolean,
+            value: true,
+        },
     },
-    value: {
+    data: {
-      type: Number,
+        hoverColor: BLUE,
-      value: 0,
-      observer: 'reRender',
     },
-    speed: {
+    methods: {
-      type: Number,
+        getContext() {
-      value: 50,
+            const { type, size } = this.data;
-    },
+            if (type === '' || !canIUseCanvas2d()) {
-    size: {
+                const ctx = wx.createCanvasContext('van-circle', this);
-      type: Number,
+                return Promise.resolve(ctx);
-      value: 100,
-      observer() {
-        this.drawCircle(this.currentValue);
-      },
-    },
-    fill: String,
-    layerColor: {
-      type: String,
-      value: WHITE,
-    },
-    color: {
-      type: null,
-      value: BLUE,
-      observer() {
-        this.setHoverColor().then(() => {
-          this.drawCircle(this.currentValue);
-        });
-      },
-    },
-    type: {
-      type: String,
-      value: '',
-    },
-    strokeWidth: {
-      type: Number,
-      value: 4,
-    },
-    clockwise: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    hoverColor: BLUE,
-  },
-  methods: {
-    getContext() {
-      const { type, size } = this.data;
-      if (type === '' || !canIUseCanvas2d()) {
-        const ctx = wx.createCanvasContext('van-circle', this);
-        return Promise.resolve(ctx);
-      }
-      const dpr = getSystemInfoSync().pixelRatio;
-      return new Promise((resolve) => {
-        wx.createSelectorQuery()
-          .in(this)
-          .select('#van-circle')
-          .node()
-          .exec((res) => {
-            const canvas = res[0].node;
-            const ctx = canvas.getContext(type);
-            if (!this.inited) {
-              this.inited = true;
-              canvas.width = size * dpr;
-              canvas.height = size * dpr;
-              ctx.scale(dpr, dpr);
             }
-            resolve(adaptor(ctx));
+            const dpr = getSystemInfoSync().pixelRatio;
-          });
+            return new Promise((resolve) => {
-      });
+                wx.createSelectorQuery()
-    },
+                    .in(this)
-    setHoverColor() {
+                    .select('#van-circle')
-      const { color, size } = this.data;
+                    .node()
-      if (isObj(color)) {
+                    .exec((res) => {
-        return this.getContext().then((context) => {
+                    const canvas = res[0].node;
-          const LinearColor = context.createLinearGradient(size, 0, 0, 0);
+                    const ctx = canvas.getContext(type);
-          Object.keys(color)
+                    if (!this.inited) {
-            .sort((a, b) => parseFloat(a) - parseFloat(b))
+                        this.inited = true;
-            .map((key) =>
+                        canvas.width = size * dpr;
-              LinearColor.addColorStop(parseFloat(key) / 100, color[key])
+                        canvas.height = size * dpr;
-            );
+                        ctx.scale(dpr, dpr);
-          this.hoverColor = LinearColor;
+                    }
-        });
+                    resolve(adaptor(ctx));
-      }
+                });
-      this.hoverColor = color;
+            });
-      return Promise.resolve();
+        },
-    },
+        setHoverColor() {
-    presetCanvas(context, strokeStyle, beginAngle, endAngle, fill) {
+            const { color, size } = this.data;
-      const { strokeWidth, lineCap, clockwise, size } = this.data;
+            if (isObj(color)) {
-      const position = size / 2;
+                return this.getContext().then((context) => {
-      const radius = position - strokeWidth / 2;
+                    const LinearColor = context.createLinearGradient(size, 0, 0, 0);
-      context.setStrokeStyle(strokeStyle);
+                    Object.keys(color)
-      context.setLineWidth(strokeWidth);
+                        .sort((a, b) => parseFloat(a) - parseFloat(b))
-      context.setLineCap(lineCap);
+                        .map((key) => LinearColor.addColorStop(parseFloat(key) / 100, color[key]));
-      context.beginPath();
+                    this.hoverColor = LinearColor;
-      context.arc(position, position, radius, beginAngle, endAngle, !clockwise);
+                });
-      context.stroke();
+            }
-      if (fill) {
+            this.hoverColor = color;
-        context.setFillStyle(fill);
+            return Promise.resolve();
-        context.fill();
+        },
-      }
+        presetCanvas(context, strokeStyle, beginAngle, endAngle, fill) {
-    },
+            const { strokeWidth, lineCap, clockwise, size } = this.data;
-    renderLayerCircle(context) {
+            const position = size / 2;
-      const { layerColor, fill } = this.data;
+            const radius = position - strokeWidth / 2;
-      this.presetCanvas(context, layerColor, 0, PERIMETER, fill);
+            context.setStrokeStyle(strokeStyle);
-    },
+            context.setLineWidth(strokeWidth);
-    renderHoverCircle(context, formatValue) {
+            context.setLineCap(lineCap);
-      const { clockwise } = this.data;
+            context.beginPath();
-      // 结束角度
+            context.arc(position, position, radius, beginAngle, endAngle, !clockwise);
-      const progress = PERIMETER * (formatValue / 100);
+            context.stroke();
-      const endAngle = clockwise
+            if (fill) {
-        ? BEGIN_ANGLE + progress
+                context.setFillStyle(fill);
-        : 3 * Math.PI - (BEGIN_ANGLE + progress);
+                context.fill();
-      this.presetCanvas(context, this.hoverColor, BEGIN_ANGLE, endAngle);
+            }
-    },
+        },
-    drawCircle(currentValue) {
+        renderLayerCircle(context) {
-      const { size } = this.data;
+            const { layerColor, fill } = this.data;
-      this.getContext().then((context) => {
+            this.presetCanvas(context, layerColor, 0, PERIMETER, fill);
-        context.clearRect(0, 0, size, size);
+        },
-        this.renderLayerCircle(context);
+        renderHoverCircle(context, formatValue) {
-        const formatValue = format(currentValue);
+            const { clockwise } = this.data;
-        if (formatValue !== 0) {
+            // 结束角度
-          this.renderHoverCircle(context, formatValue);
+            const progress = PERIMETER * (formatValue / 100);
-        }
+            const endAngle = clockwise
-        context.draw();
+                ? BEGIN_ANGLE + progress
-      });
+                : 3 * Math.PI - (BEGIN_ANGLE + progress);
-    },
+            this.presetCanvas(context, this.hoverColor, BEGIN_ANGLE, endAngle);
-    reRender() {
+        },
-      // tofector 动画暂时没有想到好的解决方案
+        drawCircle(currentValue) {
-      const { value, speed } = this.data;
+            const { size } = this.data;
-      if (speed <= 0 || speed > 1000) {
+            this.getContext().then((context) => {
-        this.drawCircle(value);
+                context.clearRect(0, 0, size, size);
-        return;
+                this.renderLayerCircle(context);
-      }
+                const formatValue = format(currentValue);
-      this.clearMockInterval();
+                if (formatValue !== 0) {
-      this.currentValue = this.currentValue || 0;
+                    this.renderHoverCircle(context, formatValue);
-      const run = () => {
+                }
-        this.interval = setTimeout(() => {
+                context.draw();
-          if (this.currentValue !== value) {
+            });
-            if (Math.abs(this.currentValue - value) < STEP) {
+        },
-              this.currentValue = value;
+        reRender() {
-            } else if (this.currentValue < value) {
+            // tofector 动画暂时没有想到好的解决方案
-              this.currentValue += STEP;
+            const { value, speed } = this.data;
-            } else {
+            if (speed <= 0 || speed > 1000) {
-              this.currentValue -= STEP;
+                this.drawCircle(value);
+                return;
             }
-            this.drawCircle(this.currentValue);
-            run();
-          } else {
             this.clearMockInterval();
-          }
+            this.currentValue = this.currentValue || 0;
-        }, 1000 / speed);
+            const run = () => {
-      };
+                this.interval = setTimeout(() => {
-      run();
+                    if (this.currentValue !== value) {
+                        if (Math.abs(this.currentValue - value) < STEP) {
+                            this.currentValue = value;
+                        }
+                        else if (this.currentValue < value) {
+                            this.currentValue += STEP;
+                        }
+                        else {
+                            this.currentValue -= STEP;
+                        }
+                        this.drawCircle(this.currentValue);
+                        run();
+                    }
+                    else {
+                        this.clearMockInterval();
+                    }
+                }, 1000 / speed);
+            };
+            run();
+        },
+        clearMockInterval() {
+            if (this.interval) {
+                clearTimeout(this.interval);
+                this.interval = null;
+            }
+        },
     },
-    clearMockInterval() {
+    mounted() {
-      if (this.interval) {
+        this.currentValue = this.data.value;
-        clearTimeout(this.interval);
+        this.setHoverColor().then(() => {
-        this.interval = null;
+            this.drawCircle(this.currentValue);
-      }
+        });
+    },
+    destroyed() {
+        this.clearMockInterval();
     },
-  },
-  mounted() {
-    this.currentValue = this.data.value;
-    this.setHoverColor().then(() => {
-      this.drawCircle(this.currentValue);
-    });
-  },
-  destroyed() {
-    this.clearMockInterval();
-  },
 });

dist/col/index.js

@@ -1,9 +1,9 @@
 import { useParent } from '../common/relation';
 import { VantComponent } from '../common/component';
 VantComponent({
-  relation: useParent('row'),
+    relation: useParent('row'),
-  props: {
+    props: {
-    span: Number,
+        span: Number,
-    offset: Number,
+        offset: Number,
-  },
+    },
 });

dist/collapse-item/animate.d.ts

@@ -1,6 +1,2 @@
 /// <reference types="miniprogram-api-typings" />
-export declare function setContentAnimate(
+export declare function setContentAnimate(context: WechatMiniprogram.Component.TrivialInstance, expanded: boolean, mounted: boolean): void;
-  context: WechatMiniprogram.Component.TrivialInstance,
-  expanded: boolean,
-  mounted: boolean
-): void;

dist/collapse-item/animate.js

@@ -1,70 +1,61 @@
 import { canIUseAnimate } from '../common/version';
 import { getRect } from '../common/utils';
 function useAnimate(context, expanded, mounted, height) {
-  const selector = '.van-collapse-item__wrapper';
+    const selector = '.van-collapse-item__wrapper';
-  if (expanded) {
+    if (expanded) {
-    context.animate(
+        context.animate(selector, [
-      selector,
+            { height: 0, ease: 'ease-in-out', offset: 0 },
-      [
+            { height: `${height}px`, ease: 'ease-in-out', offset: 1 },
-        { height: 0, ease: 'ease-in-out', offset: 0 },
+            { height: `auto`, ease: 'ease-in-out', offset: 1 },
-        { height: `${height}px`, ease: 'ease-in-out', offset: 1 },
+        ], mounted ? 300 : 0, () => {
-        { height: `auto`, ease: 'ease-in-out', offset: 1 },
+            context.clearAnimation(selector);
-      ],
+        });
-      mounted ? 300 : 0,
+        return;
-      () => {
-        context.clearAnimation(selector);
-      }
-    );
-    return;
-  }
-  context.animate(
-    selector,
-    [
-      { height: `${height}px`, ease: 'ease-in-out', offset: 0 },
-      { height: 0, ease: 'ease-in-out', offset: 1 },
-    ],
-    300,
-    () => {
-      context.clearAnimation(selector);
     }
-  );
+    context.animate(selector, [
+        { height: `${height}px`, ease: 'ease-in-out', offset: 0 },
+        { height: 0, ease: 'ease-in-out', offset: 1 },
+    ], 300, () => {
+        context.clearAnimation(selector);
+    });
 }
 function useAnimation(context, expanded, mounted, height) {
-  const animation = wx.createAnimation({
+    const animation = wx.createAnimation({
-    duration: 0,
+        duration: 0,
-    timingFunction: 'ease-in-out',
+        timingFunction: 'ease-in-out',
-  });
+    });
-  if (expanded) {
+    if (expanded) {
-    if (height === 0) {
+        if (height === 0) {
-      animation.height('auto').top(1).step();
+            animation.height('auto').top(1).step();
-    } else {
+        }
-      animation
+        else {
-        .height(height)
+            animation
-        .top(1)
+                .height(height)
-        .step({
+                .top(1)
-          duration: mounted ? 300 : 1,
+                .step({
-        })
+                duration: mounted ? 300 : 1,
-        .height('auto')
+            })
-        .step();
+                .height('auto')
-    }
+                .step();
-    context.setData({
+        }
-      animation: animation.export(),
+        context.setData({
+            animation: animation.export(),
+        });
+        return;
+    }
+    animation.height(height).top(0).step({ duration: 1 }).height(0).step({
+        duration: 300,
+    });
+    context.setData({
+        animation: animation.export(),
     });
-    return;
-  }
-  animation.height(height).top(0).step({ duration: 1 }).height(0).step({
-    duration: 300,
-  });
-  context.setData({
-    animation: animation.export(),
-  });
 }
 export function setContentAnimate(context, expanded, mounted) {
-  getRect(context, '.van-collapse-item__content')
+    getRect(context, '.van-collapse-item__content')
-    .then((rect) => rect.height)
+        .then((rect) => rect.height)
-    .then((height) => {
+        .then((height) => {
-      canIUseAnimate()
+        canIUseAnimate()
-        ? useAnimate(context, expanded, mounted, height)
+            ? useAnimate(context, expanded, mounted, height)
-        : useAnimation(context, expanded, mounted, height);
+            : useAnimation(context, expanded, mounted, height);
     });
 }

dist/collapse-item/index.js

@@ -2,58 +2,58 @@ import { VantComponent } from '../common/component';
 import { useParent } from '../common/relation';
 import { setContentAnimate } from './animate';
 VantComponent({
-  classes: ['title-class', 'content-class'],
+    classes: ['title-class', 'content-class'],
-  relation: useParent('collapse'),
+    relation: useParent('collapse'),
-  props: {
+    props: {
-    name: null,
+        name: null,
-    title: null,
+        title: null,
-    value: null,
+        value: null,
-    icon: String,
+        icon: String,
-    label: String,
+        label: String,
-    disabled: Boolean,
+        disabled: Boolean,
-    clickable: Boolean,
+        clickable: Boolean,
-    border: {
+        border: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
+        },
+        isLink: {
+            type: Boolean,
+            value: true,
+        },
     },
-    isLink: {
+    data: {
-      type: Boolean,
+        expanded: false,
-      value: true,
     },
-  },
+    mounted() {
-  data: {
+        this.updateExpanded();
-    expanded: false,
+        this.mounted = true;
-  },
-  mounted() {
-    this.updateExpanded();
-    this.mounted = true;
-  },
-  methods: {
-    updateExpanded() {
-      if (!this.parent) {
-        return;
-      }
-      const { value, accordion } = this.parent.data;
-      const { children = [] } = this.parent;
-      const { name } = this.data;
-      const index = children.indexOf(this);
-      const currentName = name == null ? index : name;
-      const expanded = accordion
-        ? value === currentName
-        : (value || []).some((name) => name === currentName);
-      if (expanded !== this.data.expanded) {
-        setContentAnimate(this, expanded, this.mounted);
-      }
-      this.setData({ index, expanded });
     },
-    onClick() {
+    methods: {
-      if (this.data.disabled) {
+        updateExpanded() {
-        return;
+            if (!this.parent) {
-      }
+                return;
-      const { name, expanded } = this.data;
+            }
-      const index = this.parent.children.indexOf(this);
+            const { value, accordion } = this.parent.data;
-      const currentName = name == null ? index : name;
+            const { children = [] } = this.parent;
-      this.parent.switch(currentName, !expanded);
+            const { name } = this.data;
+            const index = children.indexOf(this);
+            const currentName = name == null ? index : name;
+            const expanded = accordion
+                ? value === currentName
+                : (value || []).some((name) => name === currentName);
+            if (expanded !== this.data.expanded) {
+                setContentAnimate(this, expanded, this.mounted);
+            }
+            this.setData({ index, expanded });
+        },
+        onClick() {
+            if (this.data.disabled) {
+                return;
+            }
+            const { name, expanded } = this.data;
+            const index = this.parent.children.indexOf(this);
+            const currentName = name == null ? index : name;
+            this.parent.switch(currentName, !expanded);
+        },
     },
-  },
 });

dist/collapse/index.js

@@ -1,44 +1,46 @@
 import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 VantComponent({
-  relation: useChildren('collapse-item'),
+    relation: useChildren('collapse-item'),
-  props: {
+    props: {
-    value: {
+        value: {
-      type: null,
+            type: null,
-      observer: 'updateExpanded',
+            observer: 'updateExpanded',
+        },
+        accordion: {
+            type: Boolean,
+            observer: 'updateExpanded',
+        },
+        border: {
+            type: Boolean,
+            value: true,
+        },
     },
-    accordion: {
+    methods: {
-      type: Boolean,
+        updateExpanded() {
-      observer: 'updateExpanded',
+            this.children.forEach((child) => {
+                child.updateExpanded();
+            });
+        },
+        switch(name, expanded) {
+            const { accordion, value } = this.data;
+            const changeItem = name;
+            if (!accordion) {
+                name = expanded
+                    ? (value || []).concat(name)
+                    : (value || []).filter((activeName) => activeName !== name);
+            }
+            else {
+                name = expanded ? name : '';
+            }
+            if (expanded) {
+                this.$emit('open', changeItem);
+            }
+            else {
+                this.$emit('close', changeItem);
+            }
+            this.$emit('change', name);
+            this.$emit('input', name);
+        },
     },
-    border: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  methods: {
-    updateExpanded() {
-      this.children.forEach((child) => {
-        child.updateExpanded();
-      });
-    },
-    switch(name, expanded) {
-      const { accordion, value } = this.data;
-      const changeItem = name;
-      if (!accordion) {
-        name = expanded
-          ? (value || []).concat(name)
-          : (value || []).filter((activeName) => activeName !== name);
-      } else {
-        name = expanded ? name : '';
-      }
-      if (expanded) {
-        this.$emit('open', changeItem);
-      } else {
-        this.$emit('close', changeItem);
-      }
-      this.$emit('change', name);
-      this.$emit('input', name);
-    },
-  },
 });

dist/common/component.d.ts

@@ -1,8 +1,4 @@
 /// <reference types="miniprogram-api-typings" />
 import { VantComponentOptions } from '../definitions/index';
-declare function VantComponent<
+declare function VantComponent<Data extends WechatMiniprogram.Component.DataOption, Props extends WechatMiniprogram.Component.PropertyOption, Methods extends WechatMiniprogram.Component.MethodOption>(vantOptions: VantComponentOptions<Data, Props, Methods>): void;
-  Data extends WechatMiniprogram.Component.DataOption,
-  Props extends WechatMiniprogram.Component.PropertyOption,
-  Methods extends WechatMiniprogram.Component.MethodOption
->(vantOptions: VantComponentOptions<Data, Props, Methods>): void;
 export { VantComponent };

dist/common/component.js

@@ -1,45 +1,45 @@
 import { basic } from '../mixins/basic';
 function mapKeys(source, target, map) {
-  Object.keys(map).forEach((key) => {
+    Object.keys(map).forEach((key) => {
-    if (source[key]) {
+        if (source[key]) {
-      target[map[key]] = source[key];
+            target[map[key]] = source[key];
-    }
+        }
-  });
+    });
 }
 function VantComponent(vantOptions) {
-  const options = {};
+    const options = {};
-  mapKeys(vantOptions, options, {
+    mapKeys(vantOptions, options, {
-    data: 'data',
+        data: 'data',
-    props: 'properties',
+        props: 'properties',
-    mixins: 'behaviors',
+        mixins: 'behaviors',
-    methods: 'methods',
+        methods: 'methods',
-    beforeCreate: 'created',
+        beforeCreate: 'created',
-    created: 'attached',
+        created: 'attached',
-    mounted: 'ready',
+        mounted: 'ready',
-    destroyed: 'detached',
+        destroyed: 'detached',
-    classes: 'externalClasses',
+        classes: 'externalClasses',
-  });
+    });
-  // add default externalClasses
+    // add default externalClasses
-  options.externalClasses = options.externalClasses || [];
+    options.externalClasses = options.externalClasses || [];
-  options.externalClasses.push('custom-class');
+    options.externalClasses.push('custom-class');
-  // add default behaviors
+    // add default behaviors
-  options.behaviors = options.behaviors || [];
+    options.behaviors = options.behaviors || [];
-  options.behaviors.push(basic);
+    options.behaviors.push(basic);
-  // add relations
+    // add relations
-  const { relation } = vantOptions;
+    const { relation } = vantOptions;
-  if (relation) {
+    if (relation) {
-    options.relations = relation.relations;
+        options.relations = relation.relations;
-    options.behaviors.push(relation.mixin);
+        options.behaviors.push(relation.mixin);
-  }
+    }
-  // map field to form-field behavior
+    // map field to form-field behavior
-  if (vantOptions.field) {
+    if (vantOptions.field) {
-    options.behaviors.push('wx://form-field');
+        options.behaviors.push('wx://form-field');
-  }
+    }
-  // add default options
+    // add default options
-  options.options = {
+    options.options = {
-    multipleSlots: true,
+        multipleSlots: true,
-    addGlobalClass: true,
+        addGlobalClass: true,
-  };
+    };
-  Component(options);
+    Component(options);
 }
 export { VantComponent };

dist/common/relation.d.ts

@@ -1,21 +1,15 @@
 /// <reference types="miniprogram-api-typings" />
 declare type TrivialInstance = WechatMiniprogram.Component.TrivialInstance;
-export declare function useParent(
+export declare function useParent(name: string, onEffect?: (this: TrivialInstance) => void): {
-  name: string,
+    relations: {
-  onEffect?: (this: TrivialInstance) => void
+        [x: string]: WechatMiniprogram.Component.RelationOption;
-): {
+    };
-  relations: {
+    mixin: string;
-    [x: string]: WechatMiniprogram.Component.RelationOption;
-  };
-  mixin: string;
 };
-export declare function useChildren(
+export declare function useChildren(name: string, onEffect?: (this: TrivialInstance, target: TrivialInstance) => void): {
-  name: string,
+    relations: {
-  onEffect?: (this: TrivialInstance, target: TrivialInstance) => void
+        [x: string]: WechatMiniprogram.Component.RelationOption;
-): {
+    };
-  relations: {
+    mixin: string;
-    [x: string]: WechatMiniprogram.Component.RelationOption;
-  };
-  mixin: string;
 };
 export {};

dist/common/relation.js

@@ -1,64 +1,56 @@
 export function useParent(name, onEffect) {
-  const path = `../${name}/index`;
+    const path = `../${name}/index`;
-  return {
+    return {
-    relations: {
+        relations: {
-      [path]: {
+            [path]: {
-        type: 'ancestor',
+                type: 'ancestor',
-        linked() {
+                linked() {
-          onEffect && onEffect.call(this);
+                    onEffect && onEffect.call(this);
+                },
+                linkChanged() {
+                    onEffect && onEffect.call(this);
+                },
+                unlinked() {
+                    onEffect && onEffect.call(this);
+                },
+            },
         },
-        linkChanged() {
+        mixin: Behavior({
-          onEffect && onEffect.call(this);
+            created() {
-        },
+                Object.defineProperty(this, 'parent', {
-        unlinked() {
+                    get: () => this.getRelationNodes(path)[0],
-          onEffect && onEffect.call(this);
+                });
-        },
+                Object.defineProperty(this, 'index', {
-      },
+                    // @ts-ignore
-    },
+                    get: () => { var _a, _b; return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b.indexOf(this); },
-    mixin: Behavior({
+                });
-      created() {
+            },
-        Object.defineProperty(this, 'parent', {
+        }),
-          get: () => this.getRelationNodes(path)[0],
+    };
-        });
-        Object.defineProperty(this, 'index', {
-          // @ts-ignore
-          get: () => {
-            var _a, _b;
-            return (_b =
-              (_a = this.parent) === null || _a === void 0
-                ? void 0
-                : _a.children) === null || _b === void 0
-              ? void 0
-              : _b.indexOf(this);
-          },
-        });
-      },
-    }),
-  };
 }
 export function useChildren(name, onEffect) {
-  const path = `../${name}/index`;
+    const path = `../${name}/index`;
-  return {
+    return {
-    relations: {
+        relations: {
-      [path]: {
+            [path]: {
-        type: 'descendant',
+                type: 'descendant',
-        linked(target) {
+                linked(target) {
-          onEffect && onEffect.call(this, target);
+                    onEffect && onEffect.call(this, target);
+                },
+                linkChanged(target) {
+                    onEffect && onEffect.call(this, target);
+                },
+                unlinked(target) {
+                    onEffect && onEffect.call(this, target);
+                },
+            },
         },
-        linkChanged(target) {
+        mixin: Behavior({
-          onEffect && onEffect.call(this, target);
+            created() {
-        },
+                Object.defineProperty(this, 'children', {
-        unlinked(target) {
+                    get: () => this.getRelationNodes(path) || [],
-          onEffect && onEffect.call(this, target);
+                });
-        },
+            },
-      },
+        }),
-    },
+    };
-    mixin: Behavior({
-      created() {
-        Object.defineProperty(this, 'children', {
-          get: () => this.getRelationNodes(path) || [],
-        });
-      },
-    }),
-  };
 }

dist/common/utils.d.ts

@@ -4,28 +4,10 @@ export declare function range(num: number, min: number, max: number): number;
 export declare function nextTick(cb: (...args: any[]) => void): void;
 export declare function getSystemInfoSync(): WechatMiniprogram.SystemInfo;
 export declare function addUnit(value?: string | number): string | undefined;
-export declare function requestAnimationFrame(
+export declare function requestAnimationFrame(cb: () => void): number | WechatMiniprogram.NodesRef;
-  cb: () => void
-): number | WechatMiniprogram.NodesRef;
 export declare function pickExclude(obj: unknown, keys: string[]): {};
-export declare function getRect(
+export declare function getRect(context: WechatMiniprogram.Component.TrivialInstance, selector: string): Promise<WechatMiniprogram.BoundingClientRectCallbackResult>;
-  context: WechatMiniprogram.Component.TrivialInstance,
+export declare function getAllRect(context: WechatMiniprogram.Component.TrivialInstance, selector: string): Promise<WechatMiniprogram.BoundingClientRectCallbackResult[]>;
-  selector: string
+export declare function groupSetData(context: WechatMiniprogram.Component.TrivialInstance, cb: () => void): void;
-): Promise<WechatMiniprogram.BoundingClientRectCallbackResult>;
+export declare function toPromise(promiseLike: Promise<unknown> | unknown): Promise<unknown>;
-export declare function getAllRect(
+export declare function getCurrentPage<T>(): T & WechatMiniprogram.OptionalInterface<WechatMiniprogram.Page.ILifetime> & WechatMiniprogram.Page.InstanceProperties & WechatMiniprogram.Page.InstanceMethods<WechatMiniprogram.IAnyObject> & WechatMiniprogram.Page.Data<WechatMiniprogram.IAnyObject> & WechatMiniprogram.IAnyObject;
-  context: WechatMiniprogram.Component.TrivialInstance,
-  selector: string
-): Promise<WechatMiniprogram.BoundingClientRectCallbackResult[]>;
-export declare function groupSetData(
-  context: WechatMiniprogram.Component.TrivialInstance,
-  cb: () => void
-): void;
-export declare function toPromise(
-  promiseLike: Promise<unknown> | unknown
-): Promise<unknown>;
-export declare function getCurrentPage<T>(): T &
-  WechatMiniprogram.OptionalInterface<WechatMiniprogram.Page.ILifetime> &
-  WechatMiniprogram.Page.InstanceProperties &
-  WechatMiniprogram.Page.InstanceMethods<WechatMiniprogram.IAnyObject> &
-  WechatMiniprogram.Page.Data<WechatMiniprogram.IAnyObject> &
-  WechatMiniprogram.IAnyObject;

dist/common/utils.js

@@ -2,89 +2,91 @@ import { isDef, isNumber, isPlainObject, isPromise } from './validator';
 import { canIUseGroupSetData, canIUseNextTick } from './version';
 export { isDef } from './validator';
 export function range(num, min, max) {
-  return Math.min(Math.max(num, min), max);
+    return Math.min(Math.max(num, min), max);
 }
 export function nextTick(cb) {
-  if (canIUseNextTick()) {
+    if (canIUseNextTick()) {
-    wx.nextTick(cb);
+        wx.nextTick(cb);
-  } else {
+    }
-    setTimeout(() => {
+    else {
-      cb();
+        setTimeout(() => {
-    }, 1000 / 30);
+            cb();
-  }
+        }, 1000 / 30);
+    }
 }
 let systemInfo;
 export function getSystemInfoSync() {
-  if (systemInfo == null) {
+    if (systemInfo == null) {
-    systemInfo = wx.getSystemInfoSync();
+        systemInfo = wx.getSystemInfoSync();
-  }
+    }
-  return systemInfo;
+    return systemInfo;
 }
 export function addUnit(value) {
-  if (!isDef(value)) {
+    if (!isDef(value)) {
-    return undefined;
+        return undefined;
-  }
+    }
-  value = String(value);
+    value = String(value);
-  return isNumber(value) ? `${value}px` : value;
+    return isNumber(value) ? `${value}px` : value;
 }
 export function requestAnimationFrame(cb) {
-  const systemInfo = getSystemInfoSync();
+    const systemInfo = getSystemInfoSync();
-  if (systemInfo.platform === 'devtools') {
+    if (systemInfo.platform === 'devtools') {
-    return setTimeout(() => {
+        return setTimeout(() => {
-      cb();
+            cb();
-    }, 1000 / 30);
+        }, 1000 / 30);
-  }
+    }
-  return wx
+    return wx
-    .createSelectorQuery()
+        .createSelectorQuery()
-    .selectViewport()
+        .selectViewport()
-    .boundingClientRect()
+        .boundingClientRect()
-    .exec(() => {
+        .exec(() => {
-      cb();
+        cb();
     });
 }
 export function pickExclude(obj, keys) {
-  if (!isPlainObject(obj)) {
+    if (!isPlainObject(obj)) {
-    return {};
+        return {};
-  }
-  return Object.keys(obj).reduce((prev, key) => {
-    if (!keys.includes(key)) {
-      prev[key] = obj[key];
     }
-    return prev;
+    return Object.keys(obj).reduce((prev, key) => {
-  }, {});
+        if (!keys.includes(key)) {
+            prev[key] = obj[key];
+        }
+        return prev;
+    }, {});
 }
 export function getRect(context, selector) {
-  return new Promise((resolve) => {
+    return new Promise((resolve) => {
-    wx.createSelectorQuery()
+        wx.createSelectorQuery()
-      .in(context)
+            .in(context)
-      .select(selector)
+            .select(selector)
-      .boundingClientRect()
+            .boundingClientRect()
-      .exec((rect = []) => resolve(rect[0]));
+            .exec((rect = []) => resolve(rect[0]));
-  });
+    });
 }
 export function getAllRect(context, selector) {
-  return new Promise((resolve) => {
+    return new Promise((resolve) => {
-    wx.createSelectorQuery()
+        wx.createSelectorQuery()
-      .in(context)
+            .in(context)
-      .selectAll(selector)
+            .selectAll(selector)
-      .boundingClientRect()
+            .boundingClientRect()
-      .exec((rect = []) => resolve(rect[0]));
+            .exec((rect = []) => resolve(rect[0]));
-  });
+    });
 }
 export function groupSetData(context, cb) {
-  if (canIUseGroupSetData()) {
+    if (canIUseGroupSetData()) {
-    context.groupSetData(cb);
+        context.groupSetData(cb);
-  } else {
+    }
-    cb();
+    else {
-  }
+        cb();
+    }
 }
 export function toPromise(promiseLike) {
-  if (isPromise(promiseLike)) {
+    if (isPromise(promiseLike)) {
-    return promiseLike;
+        return promiseLike;
-  }
+    }
-  return Promise.resolve(promiseLike);
+    return Promise.resolve(promiseLike);
 }
 export function getCurrentPage() {
-  const pages = getCurrentPages();
+    const pages = getCurrentPages();
-  return pages[pages.length - 1];
+    return pages[pages.length - 1];
 }

dist/common/validator.d.ts

@@ -1,7 +1,5 @@
 export declare function isFunction(val: unknown): val is Function;
-export declare function isPlainObject(
+export declare function isPlainObject(val: unknown): val is Record<string, unknown>;
-  val: unknown
-): val is Record<string, unknown>;
 export declare function isPromise<T = unknown>(val: unknown): val is Promise<T>;
 export declare function isDef(value: unknown): boolean;
 export declare function isObj(x: unknown): x is Record<string, unknown>;

dist/common/validator.js

@@ -1,31 +1,31 @@
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function isFunction(val) {
-  return typeof val === 'function';
+    return typeof val === 'function';
 }
 export function isPlainObject(val) {
-  return val !== null && typeof val === 'object' && !Array.isArray(val);
+    return val !== null && typeof val === 'object' && !Array.isArray(val);
 }
 export function isPromise(val) {
-  return isPlainObject(val) && isFunction(val.then) && isFunction(val.catch);
+    return isPlainObject(val) && isFunction(val.then) && isFunction(val.catch);
 }
 export function isDef(value) {
-  return value !== undefined && value !== null;
+    return value !== undefined && value !== null;
 }
 export function isObj(x) {
-  const type = typeof x;
+    const type = typeof x;
-  return x !== null && (type === 'object' || type === 'function');
+    return x !== null && (type === 'object' || type === 'function');
 }
 export function isNumber(value) {
-  return /^\d+(\.\d+)?$/.test(value);
+    return /^\d+(\.\d+)?$/.test(value);
 }
 export function isBoolean(value) {
-  return typeof value === 'boolean';
+    return typeof value === 'boolean';
 }
 const IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i;
 const VIDEO_REGEXP = /\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv)/i;
 export function isImageUrl(url) {
-  return IMAGE_REGEXP.test(url);
+    return IMAGE_REGEXP.test(url);
 }
 export function isVideoUrl(url) {
-  return VIDEO_REGEXP.test(url);
+    return VIDEO_REGEXP.test(url);
 }

dist/common/version.js

@@ -1,48 +1,48 @@
 import { getSystemInfoSync } from './utils';
 function compareVersion(v1, v2) {
-  v1 = v1.split('.');
+    v1 = v1.split('.');
-  v2 = v2.split('.');
+    v2 = v2.split('.');
-  const len = Math.max(v1.length, v2.length);
+    const len = Math.max(v1.length, v2.length);
-  while (v1.length < len) {
+    while (v1.length < len) {
-    v1.push('0');
+        v1.push('0');
-  }
-  while (v2.length < len) {
-    v2.push('0');
-  }
-  for (let i = 0; i < len; i++) {
-    const num1 = parseInt(v1[i], 10);
-    const num2 = parseInt(v2[i], 10);
-    if (num1 > num2) {
-      return 1;
     }
-    if (num1 < num2) {
+    while (v2.length < len) {
-      return -1;
+        v2.push('0');
     }
-  }
+    for (let i = 0; i < len; i++) {
-  return 0;
+        const num1 = parseInt(v1[i], 10);
+        const num2 = parseInt(v2[i], 10);
+        if (num1 > num2) {
+            return 1;
+        }
+        if (num1 < num2) {
+            return -1;
+        }
+    }
+    return 0;
 }
 function gte(version) {
-  const system = getSystemInfoSync();
+    const system = getSystemInfoSync();
-  return compareVersion(system.SDKVersion, version) >= 0;
+    return compareVersion(system.SDKVersion, version) >= 0;
 }
 export function canIUseModel() {
-  return gte('2.9.3');
+    return gte('2.9.3');
 }
 export function canIUseFormFieldButton() {
-  return gte('2.10.3');
+    return gte('2.10.3');
 }
 export function canIUseAnimate() {
-  return gte('2.9.0');
+    return gte('2.9.0');
 }
 export function canIUseGroupSetData() {
-  return gte('2.4.0');
+    return gte('2.4.0');
 }
 export function canIUseNextTick() {
-  return wx.canIUse('nextTick');
+    return wx.canIUse('nextTick');
 }
 export function canIUseCanvas2d() {
-  return gte('2.9.0');
+    return gte('2.9.0');
 }
 export function canIUseGetUserProfile() {
-  return !!wx.getUserProfile;
+    return !!wx.getUserProfile;
 }

dist/config-provider/index.js

@@ -1,9 +1,9 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    themeVars: {
+        themeVars: {
-      type: Object,
+            type: Object,
-      value: {},
+            value: {},
+        },
     },
-  },
 });

dist/count-down/index.js

@@ -1,99 +1,100 @@
 import { VantComponent } from '../common/component';
 import { isSameSecond, parseFormat, parseTimeData } from './utils';
 function simpleTick(fn) {
-  return setTimeout(fn, 30);
+    return setTimeout(fn, 30);
 }
 VantComponent({
-  props: {
+    props: {
-    useSlot: Boolean,
+        useSlot: Boolean,
-    millisecond: Boolean,
+        millisecond: Boolean,
-    time: {
+        time: {
-      type: Number,
+            type: Number,
-      observer: 'reset',
+            observer: 'reset',
+        },
+        format: {
+            type: String,
+            value: 'HH:mm:ss',
+        },
+        autoStart: {
+            type: Boolean,
+            value: true,
+        },
     },
-    format: {
+    data: {
-      type: String,
+        timeData: parseTimeData(0),
-      value: 'HH:mm:ss',
+        formattedTime: '0',
     },
-    autoStart: {
+    destroyed() {
-      type: Boolean,
+        clearTimeout(this.tid);
-      value: true,
+        this.tid = null;
     },
-  },
+    methods: {
-  data: {
+        // 开始
-    timeData: parseTimeData(0),
+        start() {
-    formattedTime: '0',
+            if (this.counting) {
-  },
+                return;
-  destroyed() {
+            }
-    clearTimeout(this.tid);
+            this.counting = true;
-    this.tid = null;
+            this.endTime = Date.now() + this.remain;
-  },
+            this.tick();
-  methods: {
+        },
-    // 开始
+        // 暂停
-    start() {
+        pause() {
-      if (this.counting) {
+            this.counting = false;
-        return;
+            clearTimeout(this.tid);
-      }
+        },
-      this.counting = true;
+        // 重置
-      this.endTime = Date.now() + this.remain;
+        reset() {
-      this.tick();
+            this.pause();
+            this.remain = this.data.time;
+            this.setRemain(this.remain);
+            if (this.data.autoStart) {
+                this.start();
+            }
+        },
+        tick() {
+            if (this.data.millisecond) {
+                this.microTick();
+            }
+            else {
+                this.macroTick();
+            }
+        },
+        microTick() {
+            this.tid = simpleTick(() => {
+                this.setRemain(this.getRemain());
+                if (this.remain !== 0) {
+                    this.microTick();
+                }
+            });
+        },
+        macroTick() {
+            this.tid = simpleTick(() => {
+                const remain = this.getRemain();
+                if (!isSameSecond(remain, this.remain) || remain === 0) {
+                    this.setRemain(remain);
+                }
+                if (this.remain !== 0) {
+                    this.macroTick();
+                }
+            });
+        },
+        getRemain() {
+            return Math.max(this.endTime - Date.now(), 0);
+        },
+        setRemain(remain) {
+            this.remain = remain;
+            const timeData = parseTimeData(remain);
+            if (this.data.useSlot) {
+                this.$emit('change', timeData);
+            }
+            this.setData({
+                formattedTime: parseFormat(this.data.format, timeData),
+            });
+            if (remain === 0) {
+                this.pause();
+                this.$emit('finish');
+            }
+        },
     },
-    // 暂停
-    pause() {
-      this.counting = false;
-      clearTimeout(this.tid);
-    },
-    // 重置
-    reset() {
-      this.pause();
-      this.remain = this.data.time;
-      this.setRemain(this.remain);
-      if (this.data.autoStart) {
-        this.start();
-      }
-    },
-    tick() {
-      if (this.data.millisecond) {
-        this.microTick();
-      } else {
-        this.macroTick();
-      }
-    },
-    microTick() {
-      this.tid = simpleTick(() => {
-        this.setRemain(this.getRemain());
-        if (this.remain !== 0) {
-          this.microTick();
-        }
-      });
-    },
-    macroTick() {
-      this.tid = simpleTick(() => {
-        const remain = this.getRemain();
-        if (!isSameSecond(remain, this.remain) || remain === 0) {
-          this.setRemain(remain);
-        }
-        if (this.remain !== 0) {
-          this.macroTick();
-        }
-      });
-    },
-    getRemain() {
-      return Math.max(this.endTime - Date.now(), 0);
-    },
-    setRemain(remain) {
-      this.remain = remain;
-      const timeData = parseTimeData(remain);
-      if (this.data.useSlot) {
-        this.$emit('change', timeData);
-      }
-      this.setData({
-        formattedTime: parseFormat(this.data.format, timeData),
-      });
-      if (remain === 0) {
-        this.pause();
-        this.$emit('finish');
-      }
-    },
-  },
 });

dist/count-down/utils.js

@@ -1,53 +1,57 @@
 function padZero(num, targetLength = 2) {
-  let str = num + '';
+    let str = num + '';
-  while (str.length < targetLength) {
+    while (str.length < targetLength) {
-    str = '0' + str;
+        str = '0' + str;
-  }
+    }
-  return str;
+    return str;
 }
 const SECOND = 1000;
 const MINUTE = 60 * SECOND;
 const HOUR = 60 * MINUTE;
 const DAY = 24 * HOUR;
 export function parseTimeData(time) {
-  const days = Math.floor(time / DAY);
+    const days = Math.floor(time / DAY);
-  const hours = Math.floor((time % DAY) / HOUR);
+    const hours = Math.floor((time % DAY) / HOUR);
-  const minutes = Math.floor((time % HOUR) / MINUTE);
+    const minutes = Math.floor((time % HOUR) / MINUTE);
-  const seconds = Math.floor((time % MINUTE) / SECOND);
+    const seconds = Math.floor((time % MINUTE) / SECOND);
-  const milliseconds = Math.floor(time % SECOND);
+    const milliseconds = Math.floor(time % SECOND);
-  return {
+    return {
-    days,
+        days,
-    hours,
+        hours,
-    minutes,
+        minutes,
-    seconds,
+        seconds,
-    milliseconds,
+        milliseconds,
-  };
+    };
 }
 export function parseFormat(format, timeData) {
-  const { days } = timeData;
+    const { days } = timeData;
-  let { hours, minutes, seconds, milliseconds } = timeData;
+    let { hours, minutes, seconds, milliseconds } = timeData;
-  if (format.indexOf('DD') === -1) {
+    if (format.indexOf('DD') === -1) {
-    hours += days * 24;
+        hours += days * 24;
-  } else {
+    }
-    format = format.replace('DD', padZero(days));
+    else {
-  }
+        format = format.replace('DD', padZero(days));
-  if (format.indexOf('HH') === -1) {
+    }
-    minutes += hours * 60;
+    if (format.indexOf('HH') === -1) {
-  } else {
+        minutes += hours * 60;
-    format = format.replace('HH', padZero(hours));
+    }
-  }
+    else {
-  if (format.indexOf('mm') === -1) {
+        format = format.replace('HH', padZero(hours));
-    seconds += minutes * 60;
+    }
-  } else {
+    if (format.indexOf('mm') === -1) {
-    format = format.replace('mm', padZero(minutes));
+        seconds += minutes * 60;
-  }
+    }
-  if (format.indexOf('ss') === -1) {
+    else {
-    milliseconds += seconds * 1000;
+        format = format.replace('mm', padZero(minutes));
-  } else {
+    }
-    format = format.replace('ss', padZero(seconds));
+    if (format.indexOf('ss') === -1) {
-  }
+        milliseconds += seconds * 1000;
-  return format.replace('SSS', padZero(milliseconds, 3));
+    }
+    else {
+        format = format.replace('ss', padZero(seconds));
+    }
+    return format.replace('SSS', padZero(milliseconds, 3));
 }
 export function isSameSecond(time1, time2) {
-  return Math.floor(time1 / 1000) === Math.floor(time2 / 1000);
+    return Math.floor(time1 / 1000) === Math.floor(time2 / 1000);
 }

dist/datetime-picker/index.js

@@ -3,319 +3,293 @@ import { isDef } from '../common/validator';
 import { pickerProps } from '../picker/shared';
 const currentYear = new Date().getFullYear();
 function isValidDate(date) {
-  return isDef(date) && !isNaN(new Date(date).getTime());
+    return isDef(date) && !isNaN(new Date(date).getTime());
 }
 function range(num, min, max) {
-  return Math.min(Math.max(num, min), max);
+    return Math.min(Math.max(num, min), max);
 }
 function padZero(val) {
-  return `00${val}`.slice(-2);
+    return `00${val}`.slice(-2);
 }
 function times(n, iteratee) {
-  let index = -1;
+    let index = -1;
-  const result = Array(n < 0 ? 0 : n);
+    const result = Array(n < 0 ? 0 : n);
-  while (++index < n) {
+    while (++index < n) {
-    result[index] = iteratee(index);
+        result[index] = iteratee(index);
-  }
+    }
-  return result;
+    return result;
 }
 function getTrueValue(formattedValue) {
-  if (formattedValue === undefined) {
+    if (formattedValue === undefined) {
-    formattedValue = '1';
+        formattedValue = '1';
-  }
+    }
-  while (isNaN(parseInt(formattedValue, 10))) {
+    while (isNaN(parseInt(formattedValue, 10))) {
-    formattedValue = formattedValue.slice(1);
+        formattedValue = formattedValue.slice(1);
-  }
+    }
-  return parseInt(formattedValue, 10);
+    return parseInt(formattedValue, 10);
 }
 function getMonthEndDay(year, month) {
-  return 32 - new Date(year, month - 1, 32).getDate();
+    return 32 - new Date(year, month - 1, 32).getDate();
 }
 const defaultFormatter = (type, value) => value;
 VantComponent({
-  classes: ['active-class', 'toolbar-class', 'column-class'],
+    classes: ['active-class', 'toolbar-class', 'column-class'],
-  props: Object.assign(Object.assign({}, pickerProps), {
+    props: Object.assign(Object.assign({}, pickerProps), { value: {
-    value: {
+            type: null,
-      type: null,
+            observer: 'updateValue',
-      observer: 'updateValue',
+        }, filter: null, type: {
+            type: String,
+            value: 'datetime',
+            observer: 'updateValue',
+        }, showToolbar: {
+            type: Boolean,
+            value: true,
+        }, formatter: {
+            type: null,
+            value: defaultFormatter,
+        }, minDate: {
+            type: Number,
+            value: new Date(currentYear - 10, 0, 1).getTime(),
+            observer: 'updateValue',
+        }, maxDate: {
+            type: Number,
+            value: new Date(currentYear + 10, 11, 31).getTime(),
+            observer: 'updateValue',
+        }, minHour: {
+            type: Number,
+            value: 0,
+            observer: 'updateValue',
+        }, maxHour: {
+            type: Number,
+            value: 23,
+            observer: 'updateValue',
+        }, minMinute: {
+            type: Number,
+            value: 0,
+            observer: 'updateValue',
+        }, maxMinute: {
+            type: Number,
+            value: 59,
+            observer: 'updateValue',
+        } }),
+    data: {
+        innerValue: Date.now(),
+        columns: [],
     },
-    filter: null,
+    methods: {
-    type: {
+        updateValue() {
-      type: String,
+            const { data } = this;
-      value: 'datetime',
+            const val = this.correctValue(data.value);
-      observer: 'updateValue',
+            const isEqual = val === data.innerValue;
-    },
+            this.updateColumnValue(val).then(() => {
-    showToolbar: {
+                if (!isEqual) {
-      type: Boolean,
+                    this.$emit('input', val);
-      value: true,
+                }
-    },
+            });
-    formatter: {
-      type: null,
-      value: defaultFormatter,
-    },
-    minDate: {
-      type: Number,
-      value: new Date(currentYear - 10, 0, 1).getTime(),
-      observer: 'updateValue',
-    },
-    maxDate: {
-      type: Number,
-      value: new Date(currentYear + 10, 11, 31).getTime(),
-      observer: 'updateValue',
-    },
-    minHour: {
-      type: Number,
-      value: 0,
-      observer: 'updateValue',
-    },
-    maxHour: {
-      type: Number,
-      value: 23,
-      observer: 'updateValue',
-    },
-    minMinute: {
-      type: Number,
-      value: 0,
-      observer: 'updateValue',
-    },
-    maxMinute: {
-      type: Number,
-      value: 59,
-      observer: 'updateValue',
-    },
-  }),
-  data: {
-    innerValue: Date.now(),
-    columns: [],
-  },
-  methods: {
-    updateValue() {
-      const { data } = this;
-      const val = this.correctValue(data.value);
-      const isEqual = val === data.innerValue;
-      this.updateColumnValue(val).then(() => {
-        if (!isEqual) {
-          this.$emit('input', val);
-        }
-      });
-    },
-    getPicker() {
-      if (this.picker == null) {
-        this.picker = this.selectComponent('.van-datetime-picker');
-        const { picker } = this;
-        const { setColumnValues } = picker;
-        picker.setColumnValues = (...args) =>
-          setColumnValues.apply(picker, [...args, false]);
-      }
-      return this.picker;
-    },
-    updateColumns() {
-      const { formatter = defaultFormatter } = this.data;
-      const results = this.getOriginColumns().map((column) => ({
-        values: column.values.map((value) => formatter(column.type, value)),
-      }));
-      return this.set({ columns: results });
-    },
-    getOriginColumns() {
-      const { filter } = this.data;
-      const results = this.getRanges().map(({ type, range }) => {
-        let values = times(range[1] - range[0] + 1, (index) => {
-          const value = range[0] + index;
-          return type === 'year' ? `${value}` : padZero(value);
-        });
-        if (filter) {
-          values = filter(type, values);
-        }
-        return { type, values };
-      });
-      return results;
-    },
-    getRanges() {
-      const { data } = this;
-      if (data.type === 'time') {
-        return [
-          {
-            type: 'hour',
-            range: [data.minHour, data.maxHour],
-          },
-          {
-            type: 'minute',
-            range: [data.minMinute, data.maxMinute],
-          },
-        ];
-      }
-      const {
-        maxYear,
-        maxDate,
-        maxMonth,
-        maxHour,
-        maxMinute,
-      } = this.getBoundary('max', data.innerValue);
-      const {
-        minYear,
-        minDate,
-        minMonth,
-        minHour,
-        minMinute,
-      } = this.getBoundary('min', data.innerValue);
-      const result = [
-        {
-          type: 'year',
-          range: [minYear, maxYear],
         },
-        {
+        getPicker() {
-          type: 'month',
+            if (this.picker == null) {
-          range: [minMonth, maxMonth],
+                this.picker = this.selectComponent('.van-datetime-picker');
-        },
+                const { picker } = this;
-        {
+                const { setColumnValues } = picker;
-          type: 'day',
+                picker.setColumnValues = (...args) => setColumnValues.apply(picker, [...args, false]);
-          range: [minDate, maxDate],
-        },
-        {
-          type: 'hour',
-          range: [minHour, maxHour],
-        },
-        {
-          type: 'minute',
-          range: [minMinute, maxMinute],
-        },
-      ];
-      if (data.type === 'date') result.splice(3, 2);
-      if (data.type === 'year-month') result.splice(2, 3);
-      return result;
-    },
-    correctValue(value) {
-      const { data } = this;
-      // validate value
-      const isDateType = data.type !== 'time';
-      if (isDateType && !isValidDate(value)) {
-        value = data.minDate;
-      } else if (!isDateType && !value) {
-        const { minHour } = data;
-        value = `${padZero(minHour)}:00`;
-      }
-      // time type
-      if (!isDateType) {
-        let [hour, minute] = value.split(':');
-        hour = padZero(range(hour, data.minHour, data.maxHour));
-        minute = padZero(range(minute, data.minMinute, data.maxMinute));
-        return `${hour}:${minute}`;
-      }
-      // date type
-      value = Math.max(value, data.minDate);
-      value = Math.min(value, data.maxDate);
-      return value;
-    },
-    getBoundary(type, innerValue) {
-      const value = new Date(innerValue);
-      const boundary = new Date(this.data[`${type}Date`]);
-      const year = boundary.getFullYear();
-      let month = 1;
-      let date = 1;
-      let hour = 0;
-      let 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 this.picker;
-        }
+        },
-      }
+        updateColumns() {
-      return {
+            const { formatter = defaultFormatter } = this.data;
-        [`${type}Year`]: year,
+            const results = this.getOriginColumns().map((column) => ({
-        [`${type}Month`]: month,
+                values: column.values.map((value) => formatter(column.type, value)),
-        [`${type}Date`]: date,
+            }));
-        [`${type}Hour`]: hour,
+            return this.set({ columns: results });
-        [`${type}Minute`]: minute,
+        },
-      };
+        getOriginColumns() {
+            const { filter } = this.data;
+            const results = this.getRanges().map(({ type, range }) => {
+                let values = times(range[1] - range[0] + 1, (index) => {
+                    const value = range[0] + index;
+                    return type === 'year' ? `${value}` : padZero(value);
+                });
+                if (filter) {
+                    values = filter(type, values);
+                }
+                return { type, values };
+            });
+            return results;
+        },
+        getRanges() {
+            const { data } = this;
+            if (data.type === 'time') {
+                return [
+                    {
+                        type: 'hour',
+                        range: [data.minHour, data.maxHour],
+                    },
+                    {
+                        type: 'minute',
+                        range: [data.minMinute, data.maxMinute],
+                    },
+                ];
+            }
+            const { maxYear, maxDate, maxMonth, maxHour, maxMinute, } = this.getBoundary('max', data.innerValue);
+            const { minYear, minDate, minMonth, minHour, minMinute, } = this.getBoundary('min', data.innerValue);
+            const 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],
+                },
+            ];
+            if (data.type === 'date')
+                result.splice(3, 2);
+            if (data.type === 'year-month')
+                result.splice(2, 3);
+            return result;
+        },
+        correctValue(value) {
+            const { data } = this;
+            // validate value
+            const isDateType = data.type !== 'time';
+            if (isDateType && !isValidDate(value)) {
+                value = data.minDate;
+            }
+            else if (!isDateType && !value) {
+                const { minHour } = data;
+                value = `${padZero(minHour)}:00`;
+            }
+            // time type
+            if (!isDateType) {
+                let [hour, minute] = value.split(':');
+                hour = padZero(range(hour, data.minHour, data.maxHour));
+                minute = padZero(range(minute, data.minMinute, data.maxMinute));
+                return `${hour}:${minute}`;
+            }
+            // date type
+            value = Math.max(value, data.minDate);
+            value = Math.min(value, data.maxDate);
+            return value;
+        },
+        getBoundary(type, innerValue) {
+            const value = new Date(innerValue);
+            const boundary = new Date(this.data[`${type}Date`]);
+            const year = boundary.getFullYear();
+            let month = 1;
+            let date = 1;
+            let hour = 0;
+            let 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 {
+                [`${type}Year`]: year,
+                [`${type}Month`]: month,
+                [`${type}Date`]: date,
+                [`${type}Hour`]: hour,
+                [`${type}Minute`]: minute,
+            };
+        },
+        onCancel() {
+            this.$emit('cancel');
+        },
+        onConfirm() {
+            this.$emit('confirm', this.data.innerValue);
+        },
+        onChange() {
+            const { data } = this;
+            let value;
+            const picker = this.getPicker();
+            const originColumns = this.getOriginColumns();
+            if (data.type === 'time') {
+                const indexes = picker.getIndexes();
+                value = `${+originColumns[0].values[indexes[0]]}:${+originColumns[1]
+                    .values[indexes[1]]}`;
+            }
+            else {
+                const indexes = picker.getIndexes();
+                const values = indexes.map((value, index) => originColumns[index].values[value]);
+                const year = getTrueValue(values[0]);
+                const month = getTrueValue(values[1]);
+                const maxDate = getMonthEndDay(year, month);
+                let date = getTrueValue(values[2]);
+                if (data.type === 'year-month') {
+                    date = 1;
+                }
+                date = date > maxDate ? maxDate : date;
+                let hour = 0;
+                let minute = 0;
+                if (data.type === 'datetime') {
+                    hour = getTrueValue(values[3]);
+                    minute = getTrueValue(values[4]);
+                }
+                value = new Date(year, month - 1, date, hour, minute);
+            }
+            value = this.correctValue(value);
+            this.updateColumnValue(value).then(() => {
+                this.$emit('input', value);
+                this.$emit('change', picker);
+            });
+        },
+        updateColumnValue(value) {
+            let values = [];
+            const { type } = this.data;
+            const formatter = this.data.formatter || defaultFormatter;
+            const picker = this.getPicker();
+            if (type === 'time') {
+                const pair = value.split(':');
+                values = [formatter('hour', pair[0]), formatter('minute', pair[1])];
+            }
+            else {
+                const date = new Date(value);
+                values = [
+                    formatter('year', `${date.getFullYear()}`),
+                    formatter('month', padZero(date.getMonth() + 1)),
+                ];
+                if (type === 'date') {
+                    values.push(formatter('day', padZero(date.getDate())));
+                }
+                if (type === 'datetime') {
+                    values.push(formatter('day', padZero(date.getDate())), formatter('hour', padZero(date.getHours())), formatter('minute', padZero(date.getMinutes())));
+                }
+            }
+            return this.set({ innerValue: value })
+                .then(() => this.updateColumns())
+                .then(() => picker.setValues(values));
+        },
     },
-    onCancel() {
+    created() {
-      this.$emit('cancel');
+        const innerValue = this.correctValue(this.data.value);
+        this.updateColumnValue(innerValue).then(() => {
+            this.$emit('input', innerValue);
+        });
     },
-    onConfirm() {
-      this.$emit('confirm', this.data.innerValue);
-    },
-    onChange() {
-      const { data } = this;
-      let value;
-      const picker = this.getPicker();
-      const originColumns = this.getOriginColumns();
-      if (data.type === 'time') {
-        const indexes = picker.getIndexes();
-        value = `${+originColumns[0].values[indexes[0]]}:${+originColumns[1]
-          .values[indexes[1]]}`;
-      } else {
-        const indexes = picker.getIndexes();
-        const values = indexes.map(
-          (value, index) => originColumns[index].values[value]
-        );
-        const year = getTrueValue(values[0]);
-        const month = getTrueValue(values[1]);
-        const maxDate = getMonthEndDay(year, month);
-        let date = getTrueValue(values[2]);
-        if (data.type === 'year-month') {
-          date = 1;
-        }
-        date = date > maxDate ? maxDate : date;
-        let hour = 0;
-        let minute = 0;
-        if (data.type === 'datetime') {
-          hour = getTrueValue(values[3]);
-          minute = getTrueValue(values[4]);
-        }
-        value = new Date(year, month - 1, date, hour, minute);
-      }
-      value = this.correctValue(value);
-      this.updateColumnValue(value).then(() => {
-        this.$emit('input', value);
-        this.$emit('change', picker);
-      });
-    },
-    updateColumnValue(value) {
-      let values = [];
-      const { type } = this.data;
-      const formatter = this.data.formatter || defaultFormatter;
-      const picker = this.getPicker();
-      if (type === 'time') {
-        const pair = value.split(':');
-        values = [formatter('hour', pair[0]), formatter('minute', pair[1])];
-      } else {
-        const date = new Date(value);
-        values = [
-          formatter('year', `${date.getFullYear()}`),
-          formatter('month', padZero(date.getMonth() + 1)),
-        ];
-        if (type === 'date') {
-          values.push(formatter('day', padZero(date.getDate())));
-        }
-        if (type === 'datetime') {
-          values.push(
-            formatter('day', padZero(date.getDate())),
-            formatter('hour', padZero(date.getHours())),
-            formatter('minute', padZero(date.getMinutes()))
-          );
-        }
-      }
-      return this.set({ innerValue: value })
-        .then(() => this.updateColumns())
-        .then(() => picker.setValues(values));
-    },
-  },
-  created() {
-    const innerValue = this.correctValue(this.data.value);
-    this.updateColumnValue(innerValue).then(() => {
-      this.$emit('input', innerValue);
-    });
-  },
 });

dist/definitions/index.d.ts

@@ -1,43 +1,27 @@
 /// <reference types="miniprogram-api-typings" />
 interface VantComponentInstance {
-  parent: WechatMiniprogram.Component.TrivialInstance;
+    parent: WechatMiniprogram.Component.TrivialInstance;
-  children: WechatMiniprogram.Component.TrivialInstance[];
+    children: WechatMiniprogram.Component.TrivialInstance[];
-  index: number;
+    index: number;
-  $emit: (
+    $emit: (name: string, detail?: unknown, options?: WechatMiniprogram.Component.TriggerEventOption) => void;
-    name: string,
-    detail?: unknown,
-    options?: WechatMiniprogram.Component.TriggerEventOption
-  ) => void;
 }
-export declare type VantComponentOptions<
+export declare type VantComponentOptions<Data extends WechatMiniprogram.Component.DataOption, Props extends WechatMiniprogram.Component.PropertyOption, Methods extends WechatMiniprogram.Component.MethodOption> = {
-  Data extends WechatMiniprogram.Component.DataOption,
+    data?: Data;
-  Props extends WechatMiniprogram.Component.PropertyOption,
+    field?: boolean;
-  Methods extends WechatMiniprogram.Component.MethodOption
+    classes?: string[];
-> = {
+    mixins?: string[];
-  data?: Data;
+    props?: Props;
-  field?: boolean;
+    relation?: {
-  classes?: string[];
+        relations: Record<string, WechatMiniprogram.Component.RelationOption>;
-  mixins?: string[];
+        mixin: string;
-  props?: Props;
+    };
-  relation?: {
+    methods?: Methods;
-    relations: Record<string, WechatMiniprogram.Component.RelationOption>;
+    beforeCreate?: () => void;
-    mixin: string;
+    created?: () => void;
-  };
+    mounted?: () => void;
-  methods?: Methods;
+    destroyed?: () => void;
-  beforeCreate?: () => void;
+} & ThisType<VantComponentInstance & WechatMiniprogram.Component.Instance<Data & {
-  created?: () => void;
+    name: string;
-  mounted?: () => void;
+    value: any;
-  destroyed?: () => void;
+} & Record<string, any>, Props, Methods> & Record<string, any>>;
-} & ThisType<
-  VantComponentInstance &
-    WechatMiniprogram.Component.Instance<
-      Data & {
-        name: string;
-        value: any;
-      } & Record<string, any>,
-      Props,
-      Methods
-    > &
-    Record<string, any>
->;
 export {};

dist/dialog/dialog.d.ts

@@ -1,58 +1,50 @@
 /// <reference types="miniprogram-api-typings" />
 export declare type Action = 'confirm' | 'cancel' | 'overlay';
 interface DialogOptions {
-  lang?: string;
+    lang?: string;
-  show?: boolean;
+    show?: boolean;
-  title?: string;
+    title?: string;
-  width?: string | number | null;
+    width?: string | number | null;
-  zIndex?: number;
+    zIndex?: number;
-  theme?: string;
+    theme?: string;
-  context?:
+    context?: WechatMiniprogram.Page.TrivialInstance | WechatMiniprogram.Component.TrivialInstance;
-    | WechatMiniprogram.Page.TrivialInstance
+    message?: string;
-    | WechatMiniprogram.Component.TrivialInstance;
+    overlay?: boolean;
-  message?: string;
+    selector?: string;
-  overlay?: boolean;
+    ariaLabel?: string;
-  selector?: string;
+    className?: string;
-  ariaLabel?: string;
+    customStyle?: string;
-  className?: string;
+    transition?: string;
-  customStyle?: string;
+    /**
-  transition?: string;
+     * @deprecated use beforeClose instead
-  /**
+     */
-   * @deprecated use beforeClose instead
+    asyncClose?: boolean;
-   */
+    beforeClose?: null | ((action: Action) => Promise<void> | void);
-  asyncClose?: boolean;
+    businessId?: number;
-  beforeClose?: null | ((action: Action) => Promise<void> | void);
+    sessionFrom?: string;
-  businessId?: number;
+    overlayStyle?: string;
-  sessionFrom?: string;
+    appParameter?: string;
-  overlayStyle?: string;
+    messageAlign?: string;
-  appParameter?: string;
+    sendMessageImg?: string;
-  messageAlign?: string;
+    showMessageCard?: boolean;
-  sendMessageImg?: string;
+    sendMessagePath?: string;
-  showMessageCard?: boolean;
+    sendMessageTitle?: string;
-  sendMessagePath?: string;
+    confirmButtonText?: string;
-  sendMessageTitle?: string;
+    cancelButtonText?: string;
-  confirmButtonText?: string;
+    showConfirmButton?: boolean;
-  cancelButtonText?: string;
+    showCancelButton?: boolean;
-  showConfirmButton?: boolean;
+    closeOnClickOverlay?: boolean;
-  showCancelButton?: boolean;
+    confirmButtonOpenType?: string;
-  closeOnClickOverlay?: boolean;
-  confirmButtonOpenType?: string;
 }
 declare const Dialog: {
-  (options: DialogOptions): Promise<
+    (options: DialogOptions): Promise<WechatMiniprogram.Component.TrivialInstance>;
-    WechatMiniprogram.Component.TrivialInstance
+    alert(options: DialogOptions): Promise<WechatMiniprogram.Component.TrivialInstance>;
-  >;
+    confirm(options: DialogOptions): Promise<WechatMiniprogram.Component.TrivialInstance>;
-  alert(
+    close(): void;
-    options: DialogOptions
+    stopLoading(): void;
-  ): Promise<WechatMiniprogram.Component.TrivialInstance>;
+    currentOptions: DialogOptions;
-  confirm(
+    defaultOptions: DialogOptions;
-    options: DialogOptions
+    setDefaultOptions(options: DialogOptions): void;
-  ): Promise<WechatMiniprogram.Component.TrivialInstance>;
+    resetDefaultOptions(): void;
-  close(): void;
-  stopLoading(): void;
-  currentOptions: DialogOptions;
-  defaultOptions: DialogOptions;
-  setDefaultOptions(options: DialogOptions): void;
-  resetDefaultOptions(): void;
 };
 export default Dialog;

dist/dialog/dialog.js

@@ -1,84 +1,75 @@
 let queue = [];
 const defaultOptions = {
-  show: false,
+    show: false,
-  title: '',
+    title: '',
-  width: null,
+    width: null,
-  theme: 'default',
+    theme: 'default',
-  message: '',
+    message: '',
-  zIndex: 100,
+    zIndex: 100,
-  overlay: true,
+    overlay: true,
-  selector: '#van-dialog',
+    selector: '#van-dialog',
-  className: '',
+    className: '',
-  asyncClose: false,
+    asyncClose: false,
-  beforeClose: null,
+    beforeClose: null,
-  transition: 'scale',
+    transition: 'scale',
-  customStyle: '',
+    customStyle: '',
-  messageAlign: '',
+    messageAlign: '',
-  overlayStyle: '',
+    overlayStyle: '',
-  confirmButtonText: '确认',
+    confirmButtonText: '确认',
-  cancelButtonText: '取消',
+    cancelButtonText: '取消',
-  showConfirmButton: true,
+    showConfirmButton: true,
-  showCancelButton: false,
+    showCancelButton: false,
-  closeOnClickOverlay: false,
+    closeOnClickOverlay: false,
-  confirmButtonOpenType: '',
+    confirmButtonOpenType: '',
 };
 let currentOptions = Object.assign({}, defaultOptions);
 function getContext() {
-  const pages = getCurrentPages();
+    const pages = getCurrentPages();
-  return pages[pages.length - 1];
+    return pages[pages.length - 1];
 }
 const Dialog = (options) => {
-  options = Object.assign(Object.assign({}, currentOptions), options);
+    options = Object.assign(Object.assign({}, currentOptions), options);
-  return new Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
-    const context = options.context || getContext();
+        const context = options.context || getContext();
-    const dialog = context.selectComponent(options.selector);
+        const dialog = context.selectComponent(options.selector);
-    delete options.context;
+        delete options.context;
-    delete options.selector;
+        delete options.selector;
-    if (dialog) {
+        if (dialog) {
-      dialog.setData(
+            dialog.setData(Object.assign({ callback: (action, instance) => {
-        Object.assign(
+                    action === 'confirm' ? resolve(instance) : reject(instance);
-          {
+                } }, options));
-            callback: (action, instance) => {
+            wx.nextTick(() => {
-              action === 'confirm' ? resolve(instance) : reject(instance);
+                dialog.setData({ show: true });
-            },
+            });
-          },
+            queue.push(dialog);
-          options
+        }
-        )
+        else {
-      );
+            console.warn('未找到 van-dialog 节点，请确认 selector 及 context 是否正确');
-      wx.nextTick(() => {
+        }
-        dialog.setData({ show: true });
+    });
-      });
-      queue.push(dialog);
-    } else {
-      console.warn(
-        '未找到 van-dialog 节点，请确认 selector 及 context 是否正确'
-      );
-    }
-  });
 };
 Dialog.alert = (options) => Dialog(options);
-Dialog.confirm = (options) =>
+Dialog.confirm = (options) => Dialog(Object.assign({ showCancelButton: true }, options));
-  Dialog(Object.assign({ showCancelButton: true }, options));
 Dialog.close = () => {
-  queue.forEach((dialog) => {
+    queue.forEach((dialog) => {
-    dialog.close();
+        dialog.close();
-  });
+    });
-  queue = [];
+    queue = [];
 };
 Dialog.stopLoading = () => {
-  queue.forEach((dialog) => {
+    queue.forEach((dialog) => {
-    dialog.stopLoading();
+        dialog.stopLoading();
-  });
+    });
 };
 Dialog.currentOptions = currentOptions;
 Dialog.defaultOptions = defaultOptions;
 Dialog.setDefaultOptions = (options) => {
-  currentOptions = Object.assign(Object.assign({}, currentOptions), options);
+    currentOptions = Object.assign(Object.assign({}, currentOptions), options);
-  Dialog.currentOptions = currentOptions;
+    Dialog.currentOptions = currentOptions;
 };
 Dialog.resetDefaultOptions = () => {
-  currentOptions = Object.assign({}, defaultOptions);
+    currentOptions = Object.assign({}, defaultOptions);
-  Dialog.currentOptions = currentOptions;
+    Dialog.currentOptions = currentOptions;
 };
 Dialog.resetDefaultOptions();
 export default Dialog;

dist/dialog/index.js

@@ -3,119 +3,120 @@ import { button } from '../mixins/button';
 import { GRAY, RED } from '../common/color';
 import { toPromise } from '../common/utils';
 VantComponent({
-  mixins: [button],
+    mixins: [button],
-  props: {
+    props: {
-    show: {
+        show: {
-      type: Boolean,
+            type: Boolean,
-      observer(show) {
+            observer(show) {
-        !show && this.stopLoading();
+                !show && this.stopLoading();
-      },
+            },
-    },
+        },
-    title: String,
+        title: String,
-    message: String,
+        message: String,
-    theme: {
+        theme: {
-      type: String,
+            type: String,
-      value: 'default',
+            value: 'default',
-    },
+        },
-    useSlot: Boolean,
+        useSlot: Boolean,
-    className: String,
+        className: String,
-    customStyle: String,
+        customStyle: String,
-    asyncClose: Boolean,
+        asyncClose: Boolean,
-    messageAlign: String,
+        messageAlign: String,
-    beforeClose: null,
+        beforeClose: null,
-    overlayStyle: String,
+        overlayStyle: String,
-    useTitleSlot: Boolean,
+        useTitleSlot: Boolean,
-    showCancelButton: Boolean,
+        showCancelButton: Boolean,
-    closeOnClickOverlay: Boolean,
+        closeOnClickOverlay: Boolean,
-    confirmButtonOpenType: String,
+        confirmButtonOpenType: String,
-    width: null,
+        width: null,
-    zIndex: {
+        zIndex: {
-      type: Number,
+            type: Number,
-      value: 2000,
+            value: 2000,
-    },
+        },
-    confirmButtonText: {
+        confirmButtonText: {
-      type: String,
+            type: String,
-      value: '确认',
+            value: '确认',
-    },
+        },
-    cancelButtonText: {
+        cancelButtonText: {
-      type: String,
+            type: String,
-      value: '取消',
+            value: '取消',
-    },
+        },
-    confirmButtonColor: {
+        confirmButtonColor: {
-      type: String,
+            type: String,
-      value: RED,
+            value: RED,
-    },
+        },
-    cancelButtonColor: {
+        cancelButtonColor: {
-      type: String,
+            type: String,
-      value: GRAY,
+            value: GRAY,
-    },
+        },
-    showConfirmButton: {
+        showConfirmButton: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
-    },
+        },
-    overlay: {
+        overlay: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
-    },
+        },
-    transition: {
+        transition: {
-      type: String,
+            type: String,
-      value: 'scale',
+            value: 'scale',
-    },
-  },
-  data: {
-    loading: {
-      confirm: false,
-      cancel: false,
-    },
-    callback: () => {},
-  },
-  methods: {
-    onConfirm() {
-      this.handleAction('confirm');
-    },
-    onCancel() {
-      this.handleAction('cancel');
-    },
-    onClickOverlay() {
-      this.close('overlay');
-    },
-    close(action) {
-      this.setData({ show: false });
-      wx.nextTick(() => {
-        this.$emit('close', action);
-        const { callback } = this.data;
-        if (callback) {
-          callback(action, this);
-        }
-      });
-    },
-    stopLoading() {
-      this.setData({
-        loading: {
-          confirm: false,
-          cancel: false,
         },
-      });
     },
-    handleAction(action) {
+    data: {
-      this.$emit(action, { dialog: this });
+        loading: {
-      const { asyncClose, beforeClose } = this.data;
+            confirm: false,
-      if (!asyncClose && !beforeClose) {
+            cancel: false,
-        this.close(action);
+        },
-        return;
+        callback: (() => { }),
-      }
+    },
-      this.setData({
+    methods: {
-        [`loading.${action}`]: true,
+        onConfirm() {
-      });
+            this.handleAction('confirm');
-      if (beforeClose) {
+        },
-        toPromise(beforeClose(action)).then((value) => {
+        onCancel() {
-          if (value) {
+            this.handleAction('cancel');
-            this.close(action);
+        },
-          } else {
+        onClickOverlay() {
-            this.stopLoading();
+            this.close('overlay');
-          }
+        },
-        });
+        close(action) {
-      }
+            this.setData({ show: false });
+            wx.nextTick(() => {
+                this.$emit('close', action);
+                const { callback } = this.data;
+                if (callback) {
+                    callback(action, this);
+                }
+            });
+        },
+        stopLoading() {
+            this.setData({
+                loading: {
+                    confirm: false,
+                    cancel: false,
+                },
+            });
+        },
+        handleAction(action) {
+            this.$emit(action, { dialog: this });
+            const { asyncClose, beforeClose } = this.data;
+            if (!asyncClose && !beforeClose) {
+                this.close(action);
+                return;
+            }
+            this.setData({
+                [`loading.${action}`]: true,
+            });
+            if (beforeClose) {
+                toPromise(beforeClose(action)).then((value) => {
+                    if (value) {
+                        this.close(action);
+                    }
+                    else {
+                        this.stopLoading();
+                    }
+                });
+            }
+        },
     },
-  },
 });

dist/divider/index.js

@@ -1,12 +1,12 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    dashed: Boolean,
+        dashed: Boolean,
-    hairline: Boolean,
+        hairline: Boolean,
-    contentPosition: String,
+        contentPosition: String,
-    fontSize: String,
+        fontSize: String,
-    borderColor: String,
+        borderColor: String,
-    textColor: String,
+        textColor: String,
-    customStyle: String,
+        customStyle: String,
-  },
+    },
 });

dist/dropdown-item/index.js

@@ -1,111 +1,102 @@
 import { useParent } from '../common/relation';
 import { VantComponent } from '../common/component';
 VantComponent({
-  field: true,
+    field: true,
-  relation: useParent('dropdown-menu', function () {
+    relation: useParent('dropdown-menu', function () {
-    this.updateDataFromParent();
+        this.updateDataFromParent();
-  }),
+    }),
-  props: {
+    props: {
-    value: {
+        value: {
-      type: null,
+            type: null,
-      observer: 'rerender',
+            observer: 'rerender',
+        },
+        title: {
+            type: String,
+            observer: 'rerender',
+        },
+        disabled: Boolean,
+        titleClass: {
+            type: String,
+            observer: 'rerender',
+        },
+        options: {
+            type: Array,
+            value: [],
+            observer: 'rerender',
+        },
+        popupStyle: String,
     },
-    title: {
+    data: {
-      type: String,
+        transition: true,
-      observer: 'rerender',
+        showPopup: false,
+        showWrapper: false,
+        displayTitle: '',
     },
-    disabled: Boolean,
+    methods: {
-    titleClass: {
+        rerender() {
-      type: String,
+            wx.nextTick(() => {
-      observer: 'rerender',
+                var _a;
-    },
+                (_a = this.parent) === null || _a === void 0 ? void 0 : _a.updateItemListData();
-    options: {
-      type: Array,
-      value: [],
-      observer: 'rerender',
-    },
-    popupStyle: String,
-  },
-  data: {
-    transition: true,
-    showPopup: false,
-    showWrapper: false,
-    displayTitle: '',
-  },
-  methods: {
-    rerender() {
-      wx.nextTick(() => {
-        var _a;
-        (_a = this.parent) === null || _a === void 0
-          ? void 0
-          : _a.updateItemListData();
-      });
-    },
-    updateDataFromParent() {
-      if (this.parent) {
-        const {
-          overlay,
-          duration,
-          activeColor,
-          closeOnClickOverlay,
-          direction,
-        } = this.parent.data;
-        this.setData({
-          overlay,
-          duration,
-          activeColor,
-          closeOnClickOverlay,
-          direction,
-        });
-      }
-    },
-    onOpen() {
-      this.$emit('open');
-    },
-    onOpened() {
-      this.$emit('opened');
-    },
-    onClose() {
-      this.$emit('close');
-    },
-    onClosed() {
-      this.$emit('closed');
-      this.setData({ showWrapper: false });
-    },
-    onOptionTap(event) {
-      const { option } = event.currentTarget.dataset;
-      const { value } = option;
-      const shouldEmitChange = this.data.value !== value;
-      this.setData({ showPopup: false, value });
-      this.$emit('close');
-      this.rerender();
-      if (shouldEmitChange) {
-        this.$emit('change', value);
-      }
-    },
-    toggle(show, options = {}) {
-      var _a;
-      const { showPopup } = this.data;
-      if (typeof show !== 'boolean') {
-        show = !showPopup;
-      }
-      if (show === showPopup) {
-        return;
-      }
-      this.setData({
-        transition: !options.immediate,
-        showPopup: show,
-      });
-      if (show) {
-        (_a = this.parent) === null || _a === void 0
-          ? void 0
-          : _a.getChildWrapperStyle().then((wrapperStyle) => {
-              this.setData({ wrapperStyle, showWrapper: true });
-              this.rerender();
             });
-      } else {
+        },
-        this.rerender();
+        updateDataFromParent() {
-      }
+            if (this.parent) {
+                const { overlay, duration, activeColor, closeOnClickOverlay, direction, } = this.parent.data;
+                this.setData({
+                    overlay,
+                    duration,
+                    activeColor,
+                    closeOnClickOverlay,
+                    direction,
+                });
+            }
+        },
+        onOpen() {
+            this.$emit('open');
+        },
+        onOpened() {
+            this.$emit('opened');
+        },
+        onClose() {
+            this.$emit('close');
+        },
+        onClosed() {
+            this.$emit('closed');
+            this.setData({ showWrapper: false });
+        },
+        onOptionTap(event) {
+            const { option } = event.currentTarget.dataset;
+            const { value } = option;
+            const shouldEmitChange = this.data.value !== value;
+            this.setData({ showPopup: false, value });
+            this.$emit('close');
+            this.rerender();
+            if (shouldEmitChange) {
+                this.$emit('change', value);
+            }
+        },
+        toggle(show, options = {}) {
+            var _a;
+            const { showPopup } = this.data;
+            if (typeof show !== 'boolean') {
+                show = !showPopup;
+            }
+            if (show === showPopup) {
+                return;
+            }
+            this.setData({
+                transition: !options.immediate,
+                showPopup: show,
+            });
+            if (show) {
+                (_a = this.parent) === null || _a === void 0 ? void 0 : _a.getChildWrapperStyle().then((wrapperStyle) => {
+                    this.setData({ wrapperStyle, showWrapper: true });
+                    this.rerender();
+                });
+            }
+            else {
+                this.rerender();
+            }
+        },
     },
-  },
 });

dist/dropdown-item/shared.d.ts

@@ -1,5 +1,5 @@
 export interface Option {
-  text: string;
+    text: string;
-  value: string | number;
+    value: string | number;
-  icon: string;
+    icon: string;
 }

dist/dropdown-menu/index.js

@@ -3,110 +3,110 @@ import { useChildren } from '../common/relation';
 import { addUnit, getRect, getSystemInfoSync } from '../common/utils';
 let ARRAY = [];
 VantComponent({
-  field: true,
+    field: true,
-  relation: useChildren('dropdown-item', function () {
+    relation: useChildren('dropdown-item', function () {
-    this.updateItemListData();
+        this.updateItemListData();
-  }),
+    }),
-  props: {
+    props: {
-    activeColor: {
+        activeColor: {
-      type: String,
+            type: String,
-      observer: 'updateChildrenData',
+            observer: 'updateChildrenData',
+        },
+        overlay: {
+            type: Boolean,
+            value: true,
+            observer: 'updateChildrenData',
+        },
+        zIndex: {
+            type: Number,
+            value: 10,
+        },
+        duration: {
+            type: Number,
+            value: 200,
+            observer: 'updateChildrenData',
+        },
+        direction: {
+            type: String,
+            value: 'down',
+            observer: 'updateChildrenData',
+        },
+        closeOnClickOverlay: {
+            type: Boolean,
+            value: true,
+            observer: 'updateChildrenData',
+        },
+        closeOnClickOutside: {
+            type: Boolean,
+            value: true,
+        },
     },
-    overlay: {
+    data: {
-      type: Boolean,
+        itemListData: [],
-      value: true,
-      observer: 'updateChildrenData',
     },
-    zIndex: {
+    beforeCreate() {
-      type: Number,
+        const { windowHeight } = getSystemInfoSync();
-      value: 10,
+        this.windowHeight = windowHeight;
+        ARRAY.push(this);
     },
-    duration: {
+    destroyed() {
-      type: Number,
+        ARRAY = ARRAY.filter((item) => item !== this);
-      value: 200,
-      observer: 'updateChildrenData',
     },
-    direction: {
+    methods: {
-      type: String,
+        updateItemListData() {
-      value: 'down',
+            this.setData({
-      observer: 'updateChildrenData',
+                itemListData: this.children.map((child) => child.data),
+            });
+        },
+        updateChildrenData() {
+            this.children.forEach((child) => {
+                child.updateDataFromParent();
+            });
+        },
+        toggleItem(active) {
+            this.children.forEach((item, index) => {
+                const { showPopup } = item.data;
+                if (index === active) {
+                    item.toggle();
+                }
+                else if (showPopup) {
+                    item.toggle(false, { immediate: true });
+                }
+            });
+        },
+        close() {
+            this.children.forEach((child) => {
+                child.toggle(false, { immediate: true });
+            });
+        },
+        getChildWrapperStyle() {
+            const { zIndex, direction } = this.data;
+            return getRect(this, '.van-dropdown-menu').then((rect) => {
+                const { top = 0, bottom = 0 } = rect;
+                const offset = direction === 'down' ? bottom : this.windowHeight - top;
+                let wrapperStyle = `z-index: ${zIndex};`;
+                if (direction === 'down') {
+                    wrapperStyle += `top: ${addUnit(offset)};`;
+                }
+                else {
+                    wrapperStyle += `bottom: ${addUnit(offset)};`;
+                }
+                return wrapperStyle;
+            });
+        },
+        onTitleTap(event) {
+            const { index } = event.currentTarget.dataset;
+            const child = this.children[index];
+            if (!child.data.disabled) {
+                ARRAY.forEach((menuItem) => {
+                    if (menuItem &&
+                        menuItem.data.closeOnClickOutside &&
+                        menuItem !== this) {
+                        menuItem.close();
+                    }
+                });
+                this.toggleItem(index);
+            }
+        },
     },
-    closeOnClickOverlay: {
-      type: Boolean,
-      value: true,
-      observer: 'updateChildrenData',
-    },
-    closeOnClickOutside: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    itemListData: [],
-  },
-  beforeCreate() {
-    const { windowHeight } = getSystemInfoSync();
-    this.windowHeight = windowHeight;
-    ARRAY.push(this);
-  },
-  destroyed() {
-    ARRAY = ARRAY.filter((item) => item !== this);
-  },
-  methods: {
-    updateItemListData() {
-      this.setData({
-        itemListData: this.children.map((child) => child.data),
-      });
-    },
-    updateChildrenData() {
-      this.children.forEach((child) => {
-        child.updateDataFromParent();
-      });
-    },
-    toggleItem(active) {
-      this.children.forEach((item, index) => {
-        const { showPopup } = item.data;
-        if (index === active) {
-          item.toggle();
-        } else if (showPopup) {
-          item.toggle(false, { immediate: true });
-        }
-      });
-    },
-    close() {
-      this.children.forEach((child) => {
-        child.toggle(false, { immediate: true });
-      });
-    },
-    getChildWrapperStyle() {
-      const { zIndex, direction } = this.data;
-      return getRect(this, '.van-dropdown-menu').then((rect) => {
-        const { top = 0, bottom = 0 } = rect;
-        const offset = direction === 'down' ? bottom : this.windowHeight - top;
-        let wrapperStyle = `z-index: ${zIndex};`;
-        if (direction === 'down') {
-          wrapperStyle += `top: ${addUnit(offset)};`;
-        } else {
-          wrapperStyle += `bottom: ${addUnit(offset)};`;
-        }
-        return wrapperStyle;
-      });
-    },
-    onTitleTap(event) {
-      const { index } = event.currentTarget.dataset;
-      const child = this.children[index];
-      if (!child.data.disabled) {
-        ARRAY.forEach((menuItem) => {
-          if (
-            menuItem &&
-            menuItem.data.closeOnClickOutside &&
-            menuItem !== this
-          ) {
-            menuItem.close();
-          }
-        });
-        this.toggleItem(index);
-      }
-    },
-  },
 });

dist/empty/index.js

@@ -1,10 +1,10 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    description: String,
+        description: String,
-    image: {
+        image: {
-      type: String,
+            type: String,
-      value: 'default',
+            value: 'default',
+        },
     },
-  },
 });

dist/field/index.js

@@ -2,138 +2,106 @@ import { nextTick } from '../common/utils';
 import { VantComponent } from '../common/component';
 import { commonProps, inputProps, textareaProps } from './props';
 VantComponent({
-  field: true,
+    field: true,
-  classes: ['input-class', 'right-icon-class', 'label-class'],
+    classes: ['input-class', 'right-icon-class', 'label-class'],
-  props: Object.assign(
+    props: Object.assign(Object.assign(Object.assign(Object.assign({}, commonProps), inputProps), textareaProps), { size: String, icon: String, label: String, error: Boolean, center: Boolean, isLink: Boolean, leftIcon: String, rightIcon: String, autosize: null, required: Boolean, iconClass: String, clickable: Boolean, inputAlign: String, customStyle: String, errorMessage: String, arrowDirection: String, showWordLimit: Boolean, errorMessageAlign: String, readonly: {
-    Object.assign(
+            type: Boolean,
-      Object.assign(Object.assign({}, commonProps), inputProps),
+            observer: 'setShowClear',
-      textareaProps
+        }, clearable: {
-    ),
+            type: Boolean,
-    {
+            observer: 'setShowClear',
-      size: String,
+        }, clearTrigger: {
-      icon: String,
+            type: String,
-      label: String,
+            value: 'focus',
-      error: Boolean,
+        }, border: {
-      center: Boolean,
+            type: Boolean,
-      isLink: Boolean,
+            value: true,
-      leftIcon: String,
+        }, titleWidth: {
-      rightIcon: String,
+            type: String,
-      autosize: null,
+            value: '6.2em',
-      required: Boolean,
+        }, clearIcon: {
-      iconClass: String,
+            type: String,
-      clickable: Boolean,
+            value: 'clear',
-      inputAlign: String,
+        } }),
-      customStyle: String,
+    data: {
-      errorMessage: String,
+        focused: false,
-      arrowDirection: String,
+        innerValue: '',
-      showWordLimit: Boolean,
+        showClear: false,
-      errorMessageAlign: String,
-      readonly: {
-        type: Boolean,
-        observer: 'setShowClear',
-      },
-      clearable: {
-        type: Boolean,
-        observer: 'setShowClear',
-      },
-      clearTrigger: {
-        type: String,
-        value: 'focus',
-      },
-      border: {
-        type: Boolean,
-        value: true,
-      },
-      titleWidth: {
-        type: String,
-        value: '6.2em',
-      },
-      clearIcon: {
-        type: String,
-        value: 'clear',
-      },
-    }
-  ),
-  data: {
-    focused: false,
-    innerValue: '',
-    showClear: false,
-  },
-  created() {
-    this.value = this.data.value;
-    this.setData({ innerValue: this.value });
-  },
-  methods: {
-    onInput(event) {
-      const { value = '' } = event.detail || {};
-      this.value = value;
-      this.setShowClear();
-      this.emitChange();
     },
-    onFocus(event) {
+    created() {
-      this.focused = true;
+        this.value = this.data.value;
-      this.setShowClear();
+        this.setData({ innerValue: this.value });
-      this.$emit('focus', event.detail);
     },
-    onBlur(event) {
+    methods: {
-      this.focused = false;
+        onInput(event) {
-      this.setShowClear();
+            const { value = '' } = event.detail || {};
-      this.$emit('blur', event.detail);
+            this.value = value;
+            this.setShowClear();
+            this.emitChange();
+        },
+        onFocus(event) {
+            this.focused = true;
+            this.setShowClear();
+            this.$emit('focus', event.detail);
+        },
+        onBlur(event) {
+            this.focused = false;
+            this.setShowClear();
+            this.$emit('blur', event.detail);
+        },
+        onClickIcon() {
+            this.$emit('click-icon');
+        },
+        onClickInput(event) {
+            this.$emit('click-input', event.detail);
+        },
+        onClear() {
+            this.setData({ innerValue: '' });
+            this.value = '';
+            this.setShowClear();
+            nextTick(() => {
+                this.emitChange();
+                this.$emit('clear', '');
+            });
+        },
+        onConfirm(event) {
+            const { value = '' } = event.detail || {};
+            this.value = value;
+            this.setShowClear();
+            this.$emit('confirm', value);
+        },
+        setValue(value) {
+            this.value = value;
+            this.setShowClear();
+            if (value === '') {
+                this.setData({ innerValue: '' });
+            }
+            this.emitChange();
+        },
+        onLineChange(event) {
+            this.$emit('linechange', event.detail);
+        },
+        onKeyboardHeightChange(event) {
+            this.$emit('keyboardheightchange', event.detail);
+        },
+        emitChange() {
+            this.setData({ value: this.value });
+            nextTick(() => {
+                this.$emit('input', this.value);
+                this.$emit('change', this.value);
+            });
+        },
+        setShowClear() {
+            const { clearable, readonly, clearTrigger } = this.data;
+            const { focused, value } = this;
+            let showClear = false;
+            if (clearable && !readonly) {
+                const hasValue = !!value;
+                const trigger = clearTrigger === 'always' || (clearTrigger === 'focus' && focused);
+                showClear = hasValue && trigger;
+            }
+            this.setData({ showClear });
+        },
+        noop() { },
     },
-    onClickIcon() {
-      this.$emit('click-icon');
-    },
-    onClickInput(event) {
-      this.$emit('click-input', event.detail);
-    },
-    onClear() {
-      this.setData({ innerValue: '' });
-      this.value = '';
-      this.setShowClear();
-      nextTick(() => {
-        this.emitChange();
-        this.$emit('clear', '');
-      });
-    },
-    onConfirm(event) {
-      const { value = '' } = event.detail || {};
-      this.value = value;
-      this.setShowClear();
-      this.$emit('confirm', value);
-    },
-    setValue(value) {
-      this.value = value;
-      this.setShowClear();
-      if (value === '') {
-        this.setData({ innerValue: '' });
-      }
-      this.emitChange();
-    },
-    onLineChange(event) {
-      this.$emit('linechange', event.detail);
-    },
-    onKeyboardHeightChange(event) {
-      this.$emit('keyboardheightchange', event.detail);
-    },
-    emitChange() {
-      this.setData({ value: this.value });
-      nextTick(() => {
-        this.$emit('input', this.value);
-        this.$emit('change', this.value);
-      });
-    },
-    setShowClear() {
-      const { clearable, readonly, clearTrigger } = this.data;
-      const { focused, value } = this;
-      let showClear = false;
-      if (clearable && !readonly) {
-        const hasValue = !!value;
-        const trigger =
-          clearTrigger === 'always' || (clearTrigger === 'focus' && focused);
-        showClear = hasValue && trigger;
-      }
-      this.setData({ showClear });
-    },
-    noop() {},
-  },
 });

dist/field/props.js

@@ -1,63 +1,63 @@
 export const commonProps = {
-  value: {
+    value: {
-    type: String,
+        type: String,
-    observer(value) {
+        observer(value) {
-      if (value !== this.value) {
+            if (value !== this.value) {
-        this.setData({ innerValue: value });
+                this.setData({ innerValue: value });
-        this.value = value;
+                this.value = value;
-      }
+            }
+        },
     },
-  },
+    placeholder: String,
-  placeholder: String,
+    placeholderStyle: String,
-  placeholderStyle: String,
+    placeholderClass: String,
-  placeholderClass: String,
+    disabled: Boolean,
-  disabled: Boolean,
+    maxlength: {
-  maxlength: {
+        type: Number,
-    type: Number,
+        value: -1,
-    value: -1,
+    },
-  },
+    cursorSpacing: {
-  cursorSpacing: {
+        type: Number,
-    type: Number,
+        value: 50,
-    value: 50,
+    },
-  },
+    autoFocus: Boolean,
-  autoFocus: Boolean,
+    focus: Boolean,
-  focus: Boolean,
+    cursor: {
-  cursor: {
+        type: Number,
-    type: Number,
+        value: -1,
-    value: -1,
+    },
-  },
+    selectionStart: {
-  selectionStart: {
+        type: Number,
-    type: Number,
+        value: -1,
-    value: -1,
+    },
-  },
+    selectionEnd: {
-  selectionEnd: {
+        type: Number,
-    type: Number,
+        value: -1,
-    value: -1,
+    },
-  },
+    adjustPosition: {
-  adjustPosition: {
+        type: Boolean,
-    type: Boolean,
+        value: true,
-    value: true,
+    },
-  },
+    holdKeyboard: Boolean,
-  holdKeyboard: Boolean,
 };
 export const inputProps = {
-  type: {
+    type: {
-    type: String,
+        type: String,
-    value: 'text',
+        value: 'text',
-  },
+    },
-  password: Boolean,
+    password: Boolean,
-  confirmType: String,
+    confirmType: String,
-  confirmHold: Boolean,
+    confirmHold: Boolean,
 };
 export const textareaProps = {
-  autoHeight: Boolean,
+    autoHeight: Boolean,
-  fixed: Boolean,
+    fixed: Boolean,
-  showConfirmBar: {
+    showConfirmBar: {
-    type: Boolean,
+        type: Boolean,
-    value: true,
+        value: true,
-  },
+    },
-  disableDefaultPadding: {
+    disableDefaultPadding: {
-    type: Boolean,
+        type: Boolean,
-    value: true,
+        value: true,
-  },
+    },
 };

dist/goods-action-button/index.js

@@ -3,34 +3,34 @@ import { useParent } from '../common/relation';
 import { button } from '../mixins/button';
 import { link } from '../mixins/link';
 VantComponent({
-  mixins: [link, button],
+    mixins: [link, button],
-  relation: useParent('goods-action'),
+    relation: useParent('goods-action'),
-  props: {
+    props: {
-    text: String,
+        text: String,
-    color: String,
+        color: String,
-    loading: Boolean,
+        loading: Boolean,
-    disabled: Boolean,
+        disabled: Boolean,
-    plain: Boolean,
+        plain: Boolean,
-    type: {
+        type: {
-      type: String,
+            type: String,
-      value: 'danger',
+            value: 'danger',
+        },
     },
-  },
+    methods: {
-  methods: {
+        onClick(event) {
-    onClick(event) {
+            this.$emit('click', event.detail);
-      this.$emit('click', event.detail);
+            this.jumpLink();
-      this.jumpLink();
+        },
+        updateStyle() {
+            if (this.parent == null) {
+                return;
+            }
+            const { index } = this;
+            const { children = [] } = this.parent;
+            this.setData({
+                isFirst: index === 0,
+                isLast: index === children.length - 1,
+            });
+        },
     },
-    updateStyle() {
-      if (this.parent == null) {
-        return;
-      }
-      const { index } = this;
-      const { children = [] } = this.parent;
-      this.setData({
-        isFirst: index === 0,
-        isLast: index === children.length - 1,
-      });
-    },
-  },
 });

dist/goods-action-icon/index.js

@@ -2,20 +2,20 @@ import { VantComponent } from '../common/component';
 import { button } from '../mixins/button';
 import { link } from '../mixins/link';
 VantComponent({
-  classes: ['icon-class', 'text-class'],
+    classes: ['icon-class', 'text-class'],
-  mixins: [link, button],
+    mixins: [link, button],
-  props: {
+    props: {
-    text: String,
+        text: String,
-    dot: Boolean,
+        dot: Boolean,
-    info: String,
+        info: String,
-    icon: String,
+        icon: String,
-    disabled: Boolean,
+        disabled: Boolean,
-    loading: Boolean,
+        loading: Boolean,
-  },
+    },
-  methods: {
+    methods: {
-    onClick(event) {
+        onClick(event) {
-      this.$emit('click', event.detail);
+            this.$emit('click', event.detail);
-      this.jumpLink();
+            this.jumpLink();
+        },
     },
-  },
 });

dist/goods-action/index.js

@@ -1,15 +1,15 @@
 import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 VantComponent({
-  relation: useChildren('goods-action-button', function () {
+    relation: useChildren('goods-action-button', function () {
-    this.children.forEach((item) => {
+        this.children.forEach((item) => {
-      item.updateStyle();
+            item.updateStyle();
-    });
+        });
-  }),
+    }),
-  props: {
+    props: {
-    safeAreaInsetBottom: {
+        safeAreaInsetBottom: {
-      type: Boolean,
+            type: Boolean,
-      value: true,
+            value: true,
+        },
     },
-  },
 });

dist/grid-item/index.js

@@ -2,61 +2,51 @@ import { VantComponent } from '../common/component';
 import { useParent } from '../common/relation';
 import { link } from '../mixins/link';
 VantComponent({
-  relation: useParent('grid'),
+    relation: useParent('grid'),
-  classes: ['content-class', 'icon-class', 'text-class'],
+    classes: ['content-class', 'icon-class', 'text-class'],
-  mixins: [link],
+    mixins: [link],
-  props: {
+    props: {
-    icon: String,
+        icon: String,
-    iconColor: String,
+        iconColor: String,
-    iconPrefix: {
+        iconPrefix: {
-      type: String,
+            type: String,
-      value: 'van-icon',
+            value: 'van-icon',
+        },
+        dot: Boolean,
+        info: null,
+        badge: null,
+        text: String,
+        useSlot: Boolean,
     },
-    dot: Boolean,
+    data: {
-    info: null,
+        viewStyle: '',
-    badge: null,
-    text: String,
-    useSlot: Boolean,
-  },
-  data: {
-    viewStyle: '',
-  },
-  mounted() {
-    this.updateStyle();
-  },
-  methods: {
-    updateStyle() {
-      if (!this.parent) {
-        return;
-      }
-      const { data, children } = this.parent;
-      const {
-        columnNum,
-        border,
-        square,
-        gutter,
-        clickable,
-        center,
-        direction,
-        reverse,
-        iconSize,
-      } = data;
-      this.setData({
-        center,
-        border,
-        square,
-        gutter,
-        clickable,
-        direction,
-        reverse,
-        iconSize,
-        index: children.indexOf(this),
-        columnNum,
-      });
     },
-    onClick() {
+    mounted() {
-      this.$emit('click');
+        this.updateStyle();
-      this.jumpLink();
+    },
+    methods: {
+        updateStyle() {
+            if (!this.parent) {
+                return;
+            }
+            const { data, children } = this.parent;
+            const { columnNum, border, square, gutter, clickable, center, direction, reverse, iconSize, } = data;
+            this.setData({
+                center,
+                border,
+                square,
+                gutter,
+                clickable,
+                direction,
+                reverse,
+                iconSize,
+                index: children.indexOf(this),
+                columnNum,
+            });
+        },
+        onClick() {
+            this.$emit('click');
+            this.jumpLink();
+        },
     },
-  },
 });

dist/grid/index.js

@@ -1,55 +1,55 @@
 import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 VantComponent({
-  relation: useChildren('grid-item'),
+    relation: useChildren('grid-item'),
-  props: {
+    props: {
-    square: {
+        square: {
-      type: Boolean,
+            type: Boolean,
-      observer: 'updateChildren',
+            observer: 'updateChildren',
+        },
+        gutter: {
+            type: null,
+            value: 0,
+            observer: 'updateChildren',
+        },
+        clickable: {
+            type: Boolean,
+            observer: 'updateChildren',
+        },
+        columnNum: {
+            type: Number,
+            value: 4,
+            observer: 'updateChildren',
+        },
+        center: {
+            type: Boolean,
+            value: true,
+            observer: 'updateChildren',
+        },
+        border: {
+            type: Boolean,
+            value: true,
+            observer: 'updateChildren',
+        },
+        direction: {
+            type: String,
+            observer: 'updateChildren',
+        },
+        iconSize: {
+            type: String,
+            observer: 'updateChildren',
+        },
+        reverse: {
+            type: Boolean,
+            value: false,
+            observer: 'updateChildren',
+        },
     },
-    gutter: {
+    methods: {
-      type: null,
+        updateChildren() {
-      value: 0,
+            this.children.forEach((child) => {
-      observer: 'updateChildren',
+                child.updateStyle();
+            });
+        },
     },
-    clickable: {
-      type: Boolean,
-      observer: 'updateChildren',
-    },
-    columnNum: {
-      type: Number,
-      value: 4,
-      observer: 'updateChildren',
-    },
-    center: {
-      type: Boolean,
-      value: true,
-      observer: 'updateChildren',
-    },
-    border: {
-      type: Boolean,
-      value: true,
-      observer: 'updateChildren',
-    },
-    direction: {
-      type: String,
-      observer: 'updateChildren',
-    },
-    iconSize: {
-      type: String,
-      observer: 'updateChildren',
-    },
-    reverse: {
-      type: Boolean,
-      value: false,
-      observer: 'updateChildren',
-    },
-  },
-  methods: {
-    updateChildren() {
-      this.children.forEach((child) => {
-        child.updateStyle();
-      });
-    },
-  },
 });

dist/icon/index.js

@@ -1,20 +1,20 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    dot: Boolean,
+        dot: Boolean,
-    info: null,
+        info: null,
-    size: null,
+        size: null,
-    color: String,
+        color: String,
-    customStyle: String,
+        customStyle: String,
-    classPrefix: {
+        classPrefix: {
-      type: String,
+            type: String,
-      value: 'van-icon',
+            value: 'van-icon',
+        },
+        name: String,
     },
-    name: String,
+    methods: {
-  },
+        onClick() {
-  methods: {
+            this.$emit('click');
-    onClick() {
+        },
-      this.$emit('click');
     },
-  },
 });

dist/image/index.js

@@ -1,60 +1,60 @@
 import { VantComponent } from '../common/component';
 import { button } from '../mixins/button';
 VantComponent({
-  mixins: [button],
+    mixins: [button],
-  classes: ['custom-class', 'loading-class', 'error-class', 'image-class'],
+    classes: ['custom-class', 'loading-class', 'error-class', 'image-class'],
-  props: {
+    props: {
-    src: {
+        src: {
-      type: String,
+            type: String,
-      observer() {
+            observer() {
-        this.setData({
+                this.setData({
-          error: false,
+                    error: false,
-          loading: true,
+                    loading: true,
-        });
+                });
-      },
+            },
+        },
+        round: Boolean,
+        width: null,
+        height: null,
+        radius: null,
+        lazyLoad: Boolean,
+        useErrorSlot: Boolean,
+        useLoadingSlot: Boolean,
+        showMenuByLongpress: Boolean,
+        fit: {
+            type: String,
+            value: 'fill',
+        },
+        showError: {
+            type: Boolean,
+            value: true,
+        },
+        showLoading: {
+            type: Boolean,
+            value: true,
+        },
     },
-    round: Boolean,
+    data: {
-    width: null,
+        error: false,
-    height: null,
+        loading: true,
-    radius: null,
+        viewStyle: '',
-    lazyLoad: Boolean,
-    useErrorSlot: Boolean,
-    useLoadingSlot: Boolean,
-    showMenuByLongpress: Boolean,
-    fit: {
-      type: String,
-      value: 'fill',
     },
-    showError: {
+    methods: {
-      type: Boolean,
+        onLoad(event) {
-      value: true,
+            this.setData({
+                loading: false,
+            });
+            this.$emit('load', event.detail);
+        },
+        onError(event) {
+            this.setData({
+                loading: false,
+                error: true,
+            });
+            this.$emit('error', event.detail);
+        },
+        onClick(event) {
+            this.$emit('click', event.detail);
+        },
     },
-    showLoading: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    error: false,
-    loading: true,
-    viewStyle: '',
-  },
-  methods: {
-    onLoad(event) {
-      this.setData({
-        loading: false,
-      });
-      this.$emit('load', event.detail);
-    },
-    onError(event) {
-      this.setData({
-        loading: false,
-        error: true,
-      });
-      this.$emit('error', event.detail);
-    },
-    onClick(event) {
-      this.$emit('click', event.detail);
-    },
-  },
 });

dist/index-anchor/index.js

@@ -2,24 +2,24 @@ import { getRect } from '../common/utils';
 import { VantComponent } from '../common/component';
 import { useParent } from '../common/relation';
 VantComponent({
-  relation: useParent('index-bar'),
+    relation: useParent('index-bar'),
-  props: {
+    props: {
-    useSlot: Boolean,
+        useSlot: Boolean,
-    index: null,
+        index: null,
-  },
+    },
-  data: {
+    data: {
-    active: false,
+        active: false,
-    wrapperStyle: '',
+        wrapperStyle: '',
-    anchorStyle: '',
+        anchorStyle: '',
-  },
+    },
-  methods: {
+    methods: {
-    scrollIntoView(scrollTop) {
+        scrollIntoView(scrollTop) {
-      getRect(this, '.van-index-anchor-wrapper').then((rect) => {
+            getRect(this, '.van-index-anchor-wrapper').then((rect) => {
-        wx.pageScrollTo({
+                wx.pageScrollTo({
-          duration: 0,
+                    duration: 0,
-          scrollTop: scrollTop + rect.top - this.parent.data.stickyOffsetTop,
+                    scrollTop: scrollTop + rect.top - this.parent.data.stickyOffsetTop,
-        });
+                });
-      });
+            });
+        },
     },
-  },
 });

dist/index-bar/index.js

@@ -4,245 +4,240 @@ import { useChildren } from '../common/relation';
 import { getRect, isDef } from '../common/utils';
 import { pageScrollMixin } from '../mixins/page-scroll';
 const indexList = () => {
-  const indexList = [];
+    const indexList = [];
-  const charCodeOfA = 'A'.charCodeAt(0);
+    const charCodeOfA = 'A'.charCodeAt(0);
-  for (let i = 0; i < 26; i++) {
+    for (let i = 0; i < 26; i++) {
-    indexList.push(String.fromCharCode(charCodeOfA + i));
+        indexList.push(String.fromCharCode(charCodeOfA + i));
-  }
+    }
-  return indexList;
+    return indexList;
 };
 VantComponent({
-  relation: useChildren('index-anchor', function () {
+    relation: useChildren('index-anchor', function () {
-    this.updateData();
+        this.updateData();
-  }),
-  props: {
-    sticky: {
-      type: Boolean,
-      value: true,
-    },
-    zIndex: {
-      type: Number,
-      value: 1,
-    },
-    highlightColor: {
-      type: String,
-      value: GREEN,
-    },
-    stickyOffsetTop: {
-      type: Number,
-      value: 0,
-    },
-    indexList: {
-      type: Array,
-      value: indexList(),
-    },
-  },
-  mixins: [
-    pageScrollMixin(function (event) {
-      this.scrollTop =
-        (event === null || event === void 0 ? void 0 : event.scrollTop) || 0;
-      this.onScroll();
     }),
-  ],
+    props: {
-  data: {
+        sticky: {
-    activeAnchorIndex: null,
+            type: Boolean,
-    showSidebar: false,
+            value: true,
-  },
-  created() {
-    this.scrollTop = 0;
-  },
-  methods: {
-    updateData() {
-      wx.nextTick(() => {
-        if (this.timer != null) {
-          clearTimeout(this.timer);
-        }
-        this.timer = setTimeout(() => {
-          this.setData({
-            showSidebar: !!this.children.length,
-          });
-          this.setRect().then(() => {
-            this.onScroll();
-          });
-        }, 0);
-      });
-    },
-    setRect() {
-      return Promise.all([
-        this.setAnchorsRect(),
-        this.setListRect(),
-        this.setSiderbarRect(),
-      ]);
-    },
-    setAnchorsRect() {
-      return Promise.all(
-        this.children.map((anchor) =>
-          getRect(anchor, '.van-index-anchor-wrapper').then((rect) => {
-            Object.assign(anchor, {
-              height: rect.height,
-              top: rect.top + this.scrollTop,
-            });
-          })
-        )
-      );
-    },
-    setListRect() {
-      return getRect(this, '.van-index-bar').then((rect) => {
-        Object.assign(this, {
-          height: rect.height,
-          top: rect.top + this.scrollTop,
-        });
-      });
-    },
-    setSiderbarRect() {
-      return getRect(this, '.van-index-bar__sidebar').then((res) => {
-        if (!isDef(res)) {
-          return;
-        }
-        this.sidebar = {
-          height: res.height,
-          top: res.top,
-        };
-      });
-    },
-    setDiffData({ target, data }) {
-      const diffData = {};
-      Object.keys(data).forEach((key) => {
-        if (target.data[key] !== data[key]) {
-          diffData[key] = data[key];
-        }
-      });
-      if (Object.keys(diffData).length) {
-        target.setData(diffData);
-      }
-    },
-    getAnchorRect(anchor) {
-      return getRect(anchor, '.van-index-anchor-wrapper').then((rect) => ({
-        height: rect.height,
-        top: rect.top,
-      }));
-    },
-    getActiveAnchorIndex() {
-      const { children, scrollTop } = this;
-      const { sticky, stickyOffsetTop } = this.data;
-      for (let i = this.children.length - 1; i >= 0; i--) {
-        const preAnchorHeight = i > 0 ? children[i - 1].height : 0;
-        const reachTop = sticky ? preAnchorHeight + stickyOffsetTop : 0;
-        if (reachTop + scrollTop >= children[i].top) {
-          return i;
-        }
-      }
-      return -1;
-    },
-    onScroll() {
-      const { children = [], scrollTop } = this;
-      if (!children.length) {
-        return;
-      }
-      const { sticky, stickyOffsetTop, zIndex, highlightColor } = this.data;
-      const active = this.getActiveAnchorIndex();
-      this.setDiffData({
-        target: this,
-        data: {
-          activeAnchorIndex: active,
         },
-      });
+        zIndex: {
-      if (sticky) {
+            type: Number,
-        let isActiveAnchorSticky = false;
+            value: 1,
-        if (active !== -1) {
+        },
-          isActiveAnchorSticky =
+        highlightColor: {
-            children[active].top <= stickyOffsetTop + scrollTop;
+            type: String,
-        }
+            value: GREEN,
-        children.forEach((item, index) => {
+        },
-          if (index === active) {
+        stickyOffsetTop: {
-            let wrapperStyle = '';
+            type: Number,
-            let anchorStyle = `
+            value: 0,
+        },
+        indexList: {
+            type: Array,
+            value: indexList(),
+        },
+    },
+    mixins: [
+        pageScrollMixin(function (event) {
+            this.scrollTop = (event === null || event === void 0 ? void 0 : event.scrollTop) || 0;
+            this.onScroll();
+        }),
+    ],
+    data: {
+        activeAnchorIndex: null,
+        showSidebar: false,
+    },
+    created() {
+        this.scrollTop = 0;
+    },
+    methods: {
+        updateData() {
+            wx.nextTick(() => {
+                if (this.timer != null) {
+                    clearTimeout(this.timer);
+                }
+                this.timer = setTimeout(() => {
+                    this.setData({
+                        showSidebar: !!this.children.length,
+                    });
+                    this.setRect().then(() => {
+                        this.onScroll();
+                    });
+                }, 0);
+            });
+        },
+        setRect() {
+            return Promise.all([
+                this.setAnchorsRect(),
+                this.setListRect(),
+                this.setSiderbarRect(),
+            ]);
+        },
+        setAnchorsRect() {
+            return Promise.all(this.children.map((anchor) => getRect(anchor, '.van-index-anchor-wrapper').then((rect) => {
+                Object.assign(anchor, {
+                    height: rect.height,
+                    top: rect.top + this.scrollTop,
+                });
+            })));
+        },
+        setListRect() {
+            return getRect(this, '.van-index-bar').then((rect) => {
+                Object.assign(this, {
+                    height: rect.height,
+                    top: rect.top + this.scrollTop,
+                });
+            });
+        },
+        setSiderbarRect() {
+            return getRect(this, '.van-index-bar__sidebar').then((res) => {
+                if (!isDef(res)) {
+                    return;
+                }
+                this.sidebar = {
+                    height: res.height,
+                    top: res.top,
+                };
+            });
+        },
+        setDiffData({ target, data }) {
+            const diffData = {};
+            Object.keys(data).forEach((key) => {
+                if (target.data[key] !== data[key]) {
+                    diffData[key] = data[key];
+                }
+            });
+            if (Object.keys(diffData).length) {
+                target.setData(diffData);
+            }
+        },
+        getAnchorRect(anchor) {
+            return getRect(anchor, '.van-index-anchor-wrapper').then((rect) => ({
+                height: rect.height,
+                top: rect.top,
+            }));
+        },
+        getActiveAnchorIndex() {
+            const { children, scrollTop } = this;
+            const { sticky, stickyOffsetTop } = this.data;
+            for (let i = this.children.length - 1; i >= 0; i--) {
+                const preAnchorHeight = i > 0 ? children[i - 1].height : 0;
+                const reachTop = sticky ? preAnchorHeight + stickyOffsetTop : 0;
+                if (reachTop + scrollTop >= children[i].top) {
+                    return i;
+                }
+            }
+            return -1;
+        },
+        onScroll() {
+            const { children = [], scrollTop } = this;
+            if (!children.length) {
+                return;
+            }
+            const { sticky, stickyOffsetTop, zIndex, highlightColor } = this.data;
+            const active = this.getActiveAnchorIndex();
+            this.setDiffData({
+                target: this,
+                data: {
+                    activeAnchorIndex: active,
+                },
+            });
+            if (sticky) {
+                let isActiveAnchorSticky = false;
+                if (active !== -1) {
+                    isActiveAnchorSticky =
+                        children[active].top <= stickyOffsetTop + scrollTop;
+                }
+                children.forEach((item, index) => {
+                    if (index === active) {
+                        let wrapperStyle = '';
+                        let anchorStyle = `
               color: ${highlightColor};
             `;
-            if (isActiveAnchorSticky) {
+                        if (isActiveAnchorSticky) {
-              wrapperStyle = `
+                            wrapperStyle = `
                 height: ${children[index].height}px;
               `;
-              anchorStyle = `
+                            anchorStyle = `
                 position: fixed;
                 top: ${stickyOffsetTop}px;
                 z-index: ${zIndex};
                 color: ${highlightColor};
               `;
-            }
+                        }
-            this.setDiffData({
+                        this.setDiffData({
-              target: item,
+                            target: item,
-              data: {
+                            data: {
-                active: true,
+                                active: true,
-                anchorStyle,
+                                anchorStyle,
-                wrapperStyle,
+                                wrapperStyle,
-              },
+                            },
-            });
+                        });
-          } else if (index === active - 1) {
+                    }
-            const currentAnchor = children[index];
+                    else if (index === active - 1) {
-            const currentOffsetTop = currentAnchor.top;
+                        const currentAnchor = children[index];
-            const targetOffsetTop =
+                        const currentOffsetTop = currentAnchor.top;
-              index === children.length - 1
+                        const targetOffsetTop = index === children.length - 1
-                ? this.top
+                            ? this.top
-                : children[index + 1].top;
+                            : children[index + 1].top;
-            const parentOffsetHeight = targetOffsetTop - currentOffsetTop;
+                        const parentOffsetHeight = targetOffsetTop - currentOffsetTop;
-            const translateY = parentOffsetHeight - currentAnchor.height;
+                        const translateY = parentOffsetHeight - currentAnchor.height;
-            const anchorStyle = `
+                        const anchorStyle = `
               position: relative;
               transform: translate3d(0, ${translateY}px, 0);
               z-index: ${zIndex};
               color: ${highlightColor};
             `;
-            this.setDiffData({
+                        this.setDiffData({
-              target: item,
+                            target: item,
-              data: {
+                            data: {
-                active: true,
+                                active: true,
-                anchorStyle,
+                                anchorStyle,
-              },
+                            },
-            });
+                        });
-          } else {
+                    }
-            this.setDiffData({
+                    else {
-              target: item,
+                        this.setDiffData({
-              data: {
+                            target: item,
-                active: false,
+                            data: {
-                anchorStyle: '',
+                                active: false,
-                wrapperStyle: '',
+                                anchorStyle: '',
-              },
+                                wrapperStyle: '',
-            });
+                            },
-          }
+                        });
-        });
+                    }
-      }
+                });
+            }
+        },
+        onClick(event) {
+            this.scrollToAnchor(event.target.dataset.index);
+        },
+        onTouchMove(event) {
+            const sidebarLength = this.children.length;
+            const touch = event.touches[0];
+            const itemHeight = this.sidebar.height / sidebarLength;
+            let index = Math.floor((touch.clientY - this.sidebar.top) / itemHeight);
+            if (index < 0) {
+                index = 0;
+            }
+            else if (index > sidebarLength - 1) {
+                index = sidebarLength - 1;
+            }
+            this.scrollToAnchor(index);
+        },
+        onTouchStop() {
+            this.scrollToAnchorIndex = null;
+        },
+        scrollToAnchor(index) {
+            if (typeof index !== 'number' || this.scrollToAnchorIndex === index) {
+                return;
+            }
+            this.scrollToAnchorIndex = index;
+            const anchor = this.children.find((item) => item.data.index === this.data.indexList[index]);
+            if (anchor) {
+                anchor.scrollIntoView(this.scrollTop);
+                this.$emit('select', anchor.data.index);
+            }
+        },
     },
-    onClick(event) {
-      this.scrollToAnchor(event.target.dataset.index);
-    },
-    onTouchMove(event) {
-      const sidebarLength = this.children.length;
-      const touch = event.touches[0];
-      const itemHeight = this.sidebar.height / sidebarLength;
-      let index = Math.floor((touch.clientY - this.sidebar.top) / itemHeight);
-      if (index < 0) {
-        index = 0;
-      } else if (index > sidebarLength - 1) {
-        index = sidebarLength - 1;
-      }
-      this.scrollToAnchor(index);
-    },
-    onTouchStop() {
-      this.scrollToAnchorIndex = null;
-    },
-    scrollToAnchor(index) {
-      if (typeof index !== 'number' || this.scrollToAnchorIndex === index) {
-        return;
-      }
-      this.scrollToAnchorIndex = index;
-      const anchor = this.children.find(
-        (item) => item.data.index === this.data.indexList[index]
-      );
-      if (anchor) {
-        anchor.scrollIntoView(this.scrollTop);
-        this.$emit('select', anchor.data.index);
-      }
-    },
-  },
 });

dist/info/index.js

@@ -1,8 +1,8 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    dot: Boolean,
+        dot: Boolean,
-    info: null,
+        info: null,
-    customStyle: String,
+        customStyle: String,
-  },
+    },
 });

dist/loading/index.js

@@ -1,16 +1,16 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    color: String,
+        color: String,
-    vertical: Boolean,
+        vertical: Boolean,
-    type: {
+        type: {
-      type: String,
+            type: String,
-      value: 'circular',
+            value: 'circular',
+        },
+        size: String,
+        textSize: String,
+    },
+    data: {
+        array12: Array.from({ length: 12 }),
     },
-    size: String,
-    textSize: String,
-  },
-  data: {
-    array12: Array.from({ length: 12 }),
-  },
 });

dist/mixins/basic.js

@@ -1,11 +1,11 @@
 export const basic = Behavior({
-  methods: {
+    methods: {
-    $emit(name, detail, options) {
+        $emit(name, detail, options) {
-      this.triggerEvent(name, detail, options);
+            this.triggerEvent(name, detail, options);
+        },
+        set(data) {
+            this.setData(data);
+            return new Promise((resolve) => wx.nextTick(resolve));
+        },
     },
-    set(data) {
-      this.setData(data);
-      return new Promise((resolve) => wx.nextTick(resolve));
-    },
-  },
 });

dist/mixins/button.js

@@ -1,41 +1,41 @@
 import { canIUseGetUserProfile } from '../common/version';
 export const button = Behavior({
-  externalClasses: ['hover-class'],
+    externalClasses: ['hover-class'],
-  properties: {
+    properties: {
-    id: String,
+        id: String,
-    lang: String,
+        lang: String,
-    businessId: Number,
+        businessId: Number,
-    sessionFrom: String,
+        sessionFrom: String,
-    sendMessageTitle: String,
+        sendMessageTitle: String,
-    sendMessagePath: String,
+        sendMessagePath: String,
-    sendMessageImg: String,
+        sendMessageImg: String,
-    showMessageCard: Boolean,
+        showMessageCard: Boolean,
-    appParameter: String,
+        appParameter: String,
-    ariaLabel: String,
+        ariaLabel: String,
-    openType: String,
+        openType: String,
-    getUserProfileDesc: String,
+        getUserProfileDesc: String,
-  },
-  data: {
-    canIUseGetUserProfile: canIUseGetUserProfile(),
-  },
-  methods: {
-    onGetUserInfo(event) {
-      this.triggerEvent('getuserinfo', event.detail);
     },
-    onContact(event) {
+    data: {
-      this.triggerEvent('contact', event.detail);
+        canIUseGetUserProfile: canIUseGetUserProfile(),
     },
-    onGetPhoneNumber(event) {
+    methods: {
-      this.triggerEvent('getphonenumber', event.detail);
+        onGetUserInfo(event) {
+            this.triggerEvent('getuserinfo', event.detail);
+        },
+        onContact(event) {
+            this.triggerEvent('contact', event.detail);
+        },
+        onGetPhoneNumber(event) {
+            this.triggerEvent('getphonenumber', event.detail);
+        },
+        onError(event) {
+            this.triggerEvent('error', event.detail);
+        },
+        onLaunchApp(event) {
+            this.triggerEvent('launchapp', event.detail);
+        },
+        onOpenSetting(event) {
+            this.triggerEvent('opensetting', event.detail);
+        },
     },
-    onError(event) {
-      this.triggerEvent('error', event.detail);
-    },
-    onLaunchApp(event) {
-      this.triggerEvent('launchapp', event.detail);
-    },
-    onOpenSetting(event) {
-      this.triggerEvent('opensetting', event.detail);
-    },
-  },
 });

dist/mixins/link.js

@@ -1,24 +1,23 @@
 export const link = Behavior({
-  properties: {
+    properties: {
-    url: String,
+        url: String,
-    linkType: {
+        linkType: {
-      type: String,
+            type: String,
-      value: 'navigateTo',
+            value: 'navigateTo',
+        },
     },
-  },
+    methods: {
-  methods: {
+        jumpLink(urlKey = 'url') {
-    jumpLink(urlKey = 'url') {
+            const url = this.data[urlKey];
-      const url = this.data[urlKey];
+            if (url) {
-      if (url) {
+                if (this.data.linkType === 'navigateTo' &&
-        if (
+                    getCurrentPages().length > 9) {
-          this.data.linkType === 'navigateTo' &&
+                    wx.redirectTo({ url });
-          getCurrentPages().length > 9
+                }
-        ) {
+                else {
-          wx.redirectTo({ url });
+                    wx[this.data.linkType]({ url });
-        } else {
+                }
-          wx[this.data.linkType]({ url });
+            }
-        }
+        },
-      }
     },
-  },
 });

dist/mixins/page-scroll.d.ts

@@ -1,8 +1,5 @@
 /// <reference types="miniprogram-api-typings" />
 declare type IPageScrollOption = WechatMiniprogram.Page.IPageScrollOption;
-declare type Scroller = (
+declare type Scroller = (this: WechatMiniprogram.Component.TrivialInstance, event?: IPageScrollOption) => void;
-  this: WechatMiniprogram.Component.TrivialInstance,
-  event?: IPageScrollOption
-) => void;
 export declare const pageScrollMixin: (scroller: Scroller) => string;
 export {};

dist/mixins/page-scroll.js

@@ -1,35 +1,33 @@
 import { getCurrentPage, isDef } from '../common/utils';
 function onPageScroll(event) {
-  const { vanPageScroller = [] } = getCurrentPage();
+    const { vanPageScroller = [] } = getCurrentPage();
-  vanPageScroller.forEach((scroller) => {
+    vanPageScroller.forEach((scroller) => {
-    if (typeof scroller === 'function') {
+        if (typeof scroller === 'function') {
-      // @ts-ignore
+            // @ts-ignore
-      scroller(event);
+            scroller(event);
-    }
+        }
-  });
+    });
 }
-export const pageScrollMixin = (scroller) =>
+export const pageScrollMixin = (scroller) => Behavior({
-  Behavior({
     attached() {
-      const page = getCurrentPage();
+        const page = getCurrentPage();
-      if (Array.isArray(page.vanPageScroller)) {
+        if (Array.isArray(page.vanPageScroller)) {
-        page.vanPageScroller.push(scroller.bind(this));
+            page.vanPageScroller.push(scroller.bind(this));
-      } else {
+        }
-        page.vanPageScroller =
+        else {
-          typeof page.onPageScroll === 'function'
+            page.vanPageScroller =
-            ? [page.onPageScroll.bind(page), scroller.bind(this)]
+                typeof page.onPageScroll === 'function'
-            : [scroller.bind(this)];
+                    ? [page.onPageScroll.bind(page), scroller.bind(this)]
-      }
+                    : [scroller.bind(this)];
-      page.onPageScroll = onPageScroll;
+        }
+        page.onPageScroll = onPageScroll;
     },
     detached() {
-      var _a;
+        var _a;
-      const page = getCurrentPage();
+        const page = getCurrentPage();
-      if (isDef(page)) {
+        if (isDef(page)) {
-        page.vanPageScroller =
+            page.vanPageScroller =
-          ((_a = page.vanPageScroller) === null || _a === void 0
+                ((_a = page.vanPageScroller) === null || _a === void 0 ? void 0 : _a.filter((item) => item !== scroller)) || [];
-            ? void 0
+        }
-            : _a.filter((item) => item !== scroller)) || [];
-      }
     },
-  });
+});

dist/mixins/touch.js

@@ -1,37 +1,37 @@
 // @ts-nocheck
 const MIN_DISTANCE = 10;
 function getDirection(x, y) {
-  if (x > y && x > MIN_DISTANCE) {
+    if (x > y && x > MIN_DISTANCE) {
-    return 'horizontal';
+        return 'horizontal';
-  }
+    }
-  if (y > x && y > MIN_DISTANCE) {
+    if (y > x && y > MIN_DISTANCE) {
-    return 'vertical';
+        return 'vertical';
-  }
+    }
-  return '';
+    return '';
 }
 export const touch = Behavior({
-  methods: {
+    methods: {
-    resetTouchStatus() {
+        resetTouchStatus() {
-      this.direction = '';
+            this.direction = '';
-      this.deltaX = 0;
+            this.deltaX = 0;
-      this.deltaY = 0;
+            this.deltaY = 0;
-      this.offsetX = 0;
+            this.offsetX = 0;
-      this.offsetY = 0;
+            this.offsetY = 0;
+        },
+        touchStart(event) {
+            this.resetTouchStatus();
+            const touch = event.touches[0];
+            this.startX = touch.clientX;
+            this.startY = touch.clientY;
+        },
+        touchMove(event) {
+            const touch = event.touches[0];
+            this.deltaX = touch.clientX - this.startX;
+            this.deltaY = touch.clientY - this.startY;
+            this.offsetX = Math.abs(this.deltaX);
+            this.offsetY = Math.abs(this.deltaY);
+            this.direction =
+                this.direction || getDirection(this.offsetX, this.offsetY);
+        },
     },
-    touchStart(event) {
-      this.resetTouchStatus();
-      const touch = event.touches[0];
-      this.startX = touch.clientX;
-      this.startY = touch.clientY;
-    },
-    touchMove(event) {
-      const touch = event.touches[0];
-      this.deltaX = touch.clientX - this.startX;
-      this.deltaY = touch.clientY - this.startY;
-      this.offsetX = Math.abs(this.deltaX);
-      this.offsetY = Math.abs(this.deltaY);
-      this.direction =
-        this.direction || getDirection(this.offsetX, this.offsetY);
-    },
-  },
 });

dist/mixins/transition.js

@@ -2,114 +2,114 @@
 import { requestAnimationFrame } from '../common/utils';
 import { isObj } from '../common/validator';
 const getClassNames = (name) => ({
-  enter: `van-${name}-enter van-${name}-enter-active enter-class enter-active-class`,
+    enter: `van-${name}-enter van-${name}-enter-active enter-class enter-active-class`,
-  'enter-to': `van-${name}-enter-to van-${name}-enter-active enter-to-class enter-active-class`,
+    'enter-to': `van-${name}-enter-to van-${name}-enter-active enter-to-class enter-active-class`,
-  leave: `van-${name}-leave van-${name}-leave-active leave-class leave-active-class`,
+    leave: `van-${name}-leave van-${name}-leave-active leave-class leave-active-class`,
-  'leave-to': `van-${name}-leave-to van-${name}-leave-active leave-to-class leave-active-class`,
+    'leave-to': `van-${name}-leave-to van-${name}-leave-active leave-to-class leave-active-class`,
 });
 export function transition(showDefaultValue) {
-  return Behavior({
+    return Behavior({
-    properties: {
+        properties: {
-      customStyle: String,
+            customStyle: String,
-      // @ts-ignore
+            // @ts-ignore
-      show: {
+            show: {
-        type: Boolean,
+                type: Boolean,
-        value: showDefaultValue,
+                value: showDefaultValue,
-        observer: 'observeShow',
+                observer: 'observeShow',
-      },
+            },
-      // @ts-ignore
+            // @ts-ignore
-      duration: {
+            duration: {
-        type: null,
+                type: null,
-        value: 300,
+                value: 300,
-        observer: 'observeDuration',
+                observer: 'observeDuration',
-      },
+            },
-      name: {
+            name: {
-        type: String,
+                type: String,
-        value: 'fade',
+                value: 'fade',
-      },
+            },
-    },
+        },
-    data: {
+        data: {
-      type: '',
+            type: '',
-      inited: false,
+            inited: false,
-      display: false,
+            display: false,
-    },
+        },
-    ready() {
+        ready() {
-      if (this.data.show === true) {
+            if (this.data.show === true) {
-        this.observeShow(true, false);
+                this.observeShow(true, false);
-      }
-    },
-    methods: {
-      observeShow(value, old) {
-        if (value === old) {
-          return;
-        }
-        value ? this.enter() : this.leave();
-      },
-      enter() {
-        const { duration, name } = this.data;
-        const classNames = getClassNames(name);
-        const currentDuration = isObj(duration) ? duration.enter : duration;
-        this.status = 'enter';
-        this.$emit('before-enter');
-        requestAnimationFrame(() => {
-          if (this.status !== 'enter') {
-            return;
-          }
-          this.$emit('enter');
-          this.setData({
-            inited: true,
-            display: true,
-            classes: classNames.enter,
-            currentDuration,
-          });
-          requestAnimationFrame(() => {
-            if (this.status !== 'enter') {
-              return;
             }
-            this.transitionEnded = false;
+        },
-            this.setData({ classes: classNames['enter-to'] });
+        methods: {
-          });
+            observeShow(value, old) {
-        });
+                if (value === old) {
-      },
+                    return;
-      leave() {
+                }
-        if (!this.data.display) {
+                value ? this.enter() : this.leave();
-          return;
+            },
-        }
+            enter() {
-        const { duration, name } = this.data;
+                const { duration, name } = this.data;
-        const classNames = getClassNames(name);
+                const classNames = getClassNames(name);
-        const currentDuration = isObj(duration) ? duration.leave : duration;
+                const currentDuration = isObj(duration) ? duration.enter : duration;
-        this.status = 'leave';
+                this.status = 'enter';
-        this.$emit('before-leave');
+                this.$emit('before-enter');
-        requestAnimationFrame(() => {
+                requestAnimationFrame(() => {
-          if (this.status !== 'leave') {
+                    if (this.status !== 'enter') {
-            return;
+                        return;
-          }
+                    }
-          this.$emit('leave');
+                    this.$emit('enter');
-          this.setData({
+                    this.setData({
-            classes: classNames.leave,
+                        inited: true,
-            currentDuration,
+                        display: true,
-          });
+                        classes: classNames.enter,
-          requestAnimationFrame(() => {
+                        currentDuration,
-            if (this.status !== 'leave') {
+                    });
-              return;
+                    requestAnimationFrame(() => {
-            }
+                        if (this.status !== 'enter') {
-            this.transitionEnded = false;
+                            return;
-            setTimeout(() => this.onTransitionEnd(), currentDuration);
+                        }
-            this.setData({ classes: classNames['leave-to'] });
+                        this.transitionEnded = false;
-          });
+                        this.setData({ classes: classNames['enter-to'] });
-        });
+                    });
-      },
+                });
-      onTransitionEnd() {
+            },
-        if (this.transitionEnded) {
+            leave() {
-          return;
+                if (!this.data.display) {
-        }
+                    return;
-        this.transitionEnded = true;
+                }
-        this.$emit(`after-${this.status}`);
+                const { duration, name } = this.data;
-        const { show, display } = this.data;
+                const classNames = getClassNames(name);
-        if (!show && display) {
+                const currentDuration = isObj(duration) ? duration.leave : duration;
-          this.setData({ display: false });
+                this.status = 'leave';
-        }
+                this.$emit('before-leave');
-      },
+                requestAnimationFrame(() => {
-    },
+                    if (this.status !== 'leave') {
-  });
+                        return;
+                    }
+                    this.$emit('leave');
+                    this.setData({
+                        classes: classNames.leave,
+                        currentDuration,
+                    });
+                    requestAnimationFrame(() => {
+                        if (this.status !== 'leave') {
+                            return;
+                        }
+                        this.transitionEnded = false;
+                        setTimeout(() => this.onTransitionEnd(), currentDuration);
+                        this.setData({ classes: classNames['leave-to'] });
+                    });
+                });
+            },
+            onTransitionEnd() {
+                if (this.transitionEnded) {
+                    return;
+                }
+                this.transitionEnded = true;
+                this.$emit(`after-${this.status}`);
+                const { show, display } = this.data;
+                if (!show && display) {
+                    this.setData({ display: false });
+                }
+            },
+        },
+    });
 }

dist/nav-bar/index.js

@@ -1,65 +1,65 @@
 import { VantComponent } from '../common/component';
 import { getRect, getSystemInfoSync } from '../common/utils';
 VantComponent({
-  classes: ['title-class'],
+    classes: ['title-class'],
-  props: {
+    props: {
-    title: String,
+        title: String,
-    fixed: {
+        fixed: {
-      type: Boolean,
+            type: Boolean,
-      observer: 'setHeight',
+            observer: 'setHeight',
+        },
+        placeholder: {
+            type: Boolean,
+            observer: 'setHeight',
+        },
+        leftText: String,
+        rightText: String,
+        customStyle: String,
+        leftArrow: Boolean,
+        border: {
+            type: Boolean,
+            value: true,
+        },
+        zIndex: {
+            type: Number,
+            value: 1,
+        },
+        safeAreaInsetTop: {
+            type: Boolean,
+            value: true,
+        },
     },
-    placeholder: {
+    data: {
-      type: Boolean,
+        height: 46,
-      observer: 'setHeight',
     },
-    leftText: String,
+    created() {
-    rightText: String,
+        const { statusBarHeight } = getSystemInfoSync();
-    customStyle: String,
+        this.setData({
-    leftArrow: Boolean,
+            statusBarHeight,
-    border: {
+            height: 46 + statusBarHeight,
-      type: Boolean,
-      value: true,
-    },
-    zIndex: {
-      type: Number,
-      value: 1,
-    },
-    safeAreaInsetTop: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    height: 46,
-  },
-  created() {
-    const { statusBarHeight } = getSystemInfoSync();
-    this.setData({
-      statusBarHeight,
-      height: 46 + statusBarHeight,
-    });
-  },
-  mounted() {
-    this.setHeight();
-  },
-  methods: {
-    onClickLeft() {
-      this.$emit('click-left');
-    },
-    onClickRight() {
-      this.$emit('click-right');
-    },
-    setHeight() {
-      if (!this.data.fixed || !this.data.placeholder) {
-        return;
-      }
-      wx.nextTick(() => {
-        getRect(this, '.van-nav-bar').then((res) => {
-          if (res && 'height' in res) {
-            this.setData({ height: res.height });
-          }
         });
-      });
     },
-  },
+    mounted() {
+        this.setHeight();
+    },
+    methods: {
+        onClickLeft() {
+            this.$emit('click-left');
+        },
+        onClickRight() {
+            this.$emit('click-right');
+        },
+        setHeight() {
+            if (!this.data.fixed || !this.data.placeholder) {
+                return;
+            }
+            wx.nextTick(() => {
+                getRect(this, '.van-nav-bar').then((res) => {
+                    if (res && 'height' in res) {
+                        this.setData({ height: res.height });
+                    }
+                });
+            });
+        },
+    },
 });

dist/notice-bar/index.js

@@ -1,123 +1,120 @@
 import { VantComponent } from '../common/component';
 import { getRect, requestAnimationFrame } from '../common/utils';
 VantComponent({
-  props: {
+    props: {
-    text: {
+        text: {
-      type: String,
+            type: String,
-      value: '',
+            value: '',
-      observer: 'init',
+            observer: 'init',
+        },
+        mode: {
+            type: String,
+            value: '',
+        },
+        url: {
+            type: String,
+            value: '',
+        },
+        openType: {
+            type: String,
+            value: 'navigate',
+        },
+        delay: {
+            type: Number,
+            value: 1,
+        },
+        speed: {
+            type: Number,
+            value: 60,
+            observer: 'init',
+        },
+        scrollable: null,
+        leftIcon: {
+            type: String,
+            value: '',
+        },
+        color: String,
+        backgroundColor: String,
+        background: String,
+        wrapable: Boolean,
     },
-    mode: {
+    data: {
-      type: String,
+        show: true,
-      value: '',
     },
-    url: {
+    created() {
-      type: String,
+        this.resetAnimation = wx.createAnimation({
-      value: '',
+            duration: 0,
-    },
+            timingFunction: 'linear',
-    openType: {
-      type: String,
-      value: 'navigate',
-    },
-    delay: {
-      type: Number,
-      value: 1,
-    },
-    speed: {
-      type: Number,
-      value: 60,
-      observer: 'init',
-    },
-    scrollable: null,
-    leftIcon: {
-      type: String,
-      value: '',
-    },
-    color: String,
-    backgroundColor: String,
-    background: String,
-    wrapable: Boolean,
-  },
-  data: {
-    show: true,
-  },
-  created() {
-    this.resetAnimation = wx.createAnimation({
-      duration: 0,
-      timingFunction: 'linear',
-    });
-  },
-  destroyed() {
-    this.timer && clearTimeout(this.timer);
-  },
-  mounted() {
-    this.init();
-  },
-  methods: {
-    init() {
-      requestAnimationFrame(() => {
-        Promise.all([
-          getRect(this, '.van-notice-bar__content'),
-          getRect(this, '.van-notice-bar__wrap'),
-        ]).then((rects) => {
-          const [contentRect, wrapRect] = rects;
-          const { speed, scrollable, delay } = this.data;
-          if (
-            contentRect == null ||
-            wrapRect == null ||
-            !contentRect.width ||
-            !wrapRect.width ||
-            scrollable === false
-          ) {
-            return;
-          }
-          if (scrollable || wrapRect.width < contentRect.width) {
-            const duration =
-              ((wrapRect.width + contentRect.width) / speed) * 1000;
-            this.wrapWidth = wrapRect.width;
-            this.contentWidth = contentRect.width;
-            this.duration = duration;
-            this.animation = wx.createAnimation({
-              duration,
-              timingFunction: 'linear',
-              delay,
-            });
-            this.scroll();
-          }
         });
-      });
     },
-    scroll() {
+    destroyed() {
-      this.timer && clearTimeout(this.timer);
-      this.timer = null;
-      this.setData({
-        animationData: this.resetAnimation
-          .translateX(this.wrapWidth)
-          .step()
-          .export(),
-      });
-      requestAnimationFrame(() => {
-        this.setData({
-          animationData: this.animation
-            .translateX(-this.contentWidth)
-            .step()
-            .export(),
-        });
-      });
-      this.timer = setTimeout(() => {
-        this.scroll();
-      }, this.duration);
-    },
-    onClickIcon(event) {
-      if (this.data.mode === 'closeable') {
         this.timer && clearTimeout(this.timer);
-        this.timer = null;
-        this.setData({ show: false });
-        this.$emit('close', event.detail);
-      }
     },
-    onClick(event) {
+    mounted() {
-      this.$emit('click', event);
+        this.init();
+    },
+    methods: {
+        init() {
+            requestAnimationFrame(() => {
+                Promise.all([
+                    getRect(this, '.van-notice-bar__content'),
+                    getRect(this, '.van-notice-bar__wrap'),
+                ]).then((rects) => {
+                    const [contentRect, wrapRect] = rects;
+                    const { speed, scrollable, delay } = this.data;
+                    if (contentRect == null ||
+                        wrapRect == null ||
+                        !contentRect.width ||
+                        !wrapRect.width ||
+                        scrollable === false) {
+                        return;
+                    }
+                    if (scrollable || wrapRect.width < contentRect.width) {
+                        const duration = ((wrapRect.width + contentRect.width) / speed) * 1000;
+                        this.wrapWidth = wrapRect.width;
+                        this.contentWidth = contentRect.width;
+                        this.duration = duration;
+                        this.animation = wx.createAnimation({
+                            duration,
+                            timingFunction: 'linear',
+                            delay,
+                        });
+                        this.scroll();
+                    }
+                });
+            });
+        },
+        scroll() {
+            this.timer && clearTimeout(this.timer);
+            this.timer = null;
+            this.setData({
+                animationData: this.resetAnimation
+                    .translateX(this.wrapWidth)
+                    .step()
+                    .export(),
+            });
+            requestAnimationFrame(() => {
+                this.setData({
+                    animationData: this.animation
+                        .translateX(-this.contentWidth)
+                        .step()
+                        .export(),
+                });
+            });
+            this.timer = setTimeout(() => {
+                this.scroll();
+            }, this.duration);
+        },
+        onClickIcon(event) {
+            if (this.data.mode === 'closeable') {
+                this.timer && clearTimeout(this.timer);
+                this.timer = null;
+                this.setData({ show: false });
+                this.$emit('close', event.detail);
+            }
+        },
+        onClick(event) {
+            this.$emit('click', event);
+        },
     },
-  },
 });

dist/notify/index.js

@@ -2,64 +2,64 @@ import { VantComponent } from '../common/component';
 import { WHITE } from '../common/color';
 import { getSystemInfoSync } from '../common/utils';
 VantComponent({
-  props: {
+    props: {
-    message: String,
+        message: String,
-    background: String,
+        background: String,
-    type: {
+        type: {
-      type: String,
+            type: String,
-      value: 'danger',
+            value: 'danger',
+        },
+        color: {
+            type: String,
+            value: WHITE,
+        },
+        duration: {
+            type: Number,
+            value: 3000,
+        },
+        zIndex: {
+            type: Number,
+            value: 110,
+        },
+        safeAreaInsetTop: {
+            type: Boolean,
+            value: false,
+        },
+        top: null,
     },
-    color: {
+    data: {
-      type: String,
+        show: false,
-      value: WHITE,
+        onOpened: null,
+        onClose: null,
+        onClick: null,
     },
-    duration: {
+    created() {
-      type: Number,
+        const { statusBarHeight } = getSystemInfoSync();
-      value: 3000,
+        this.setData({ statusBarHeight });
     },
-    zIndex: {
+    methods: {
-      type: Number,
+        show() {
-      value: 110,
+            const { duration, onOpened } = this.data;
+            clearTimeout(this.timer);
+            this.setData({ show: true });
+            wx.nextTick(onOpened);
+            if (duration > 0 && duration !== Infinity) {
+                this.timer = setTimeout(() => {
+                    this.hide();
+                }, duration);
+            }
+        },
+        hide() {
+            const { onClose } = this.data;
+            clearTimeout(this.timer);
+            this.setData({ show: false });
+            wx.nextTick(onClose);
+        },
+        onTap(event) {
+            const { onClick } = this.data;
+            if (onClick) {
+                onClick(event.detail);
+            }
+        },
     },
-    safeAreaInsetTop: {
-      type: Boolean,
-      value: false,
-    },
-    top: null,
-  },
-  data: {
-    show: false,
-    onOpened: null,
-    onClose: null,
-    onClick: null,
-  },
-  created() {
-    const { statusBarHeight } = getSystemInfoSync();
-    this.setData({ statusBarHeight });
-  },
-  methods: {
-    show() {
-      const { duration, onOpened } = this.data;
-      clearTimeout(this.timer);
-      this.setData({ show: true });
-      wx.nextTick(onOpened);
-      if (duration > 0 && duration !== Infinity) {
-        this.timer = setTimeout(() => {
-          this.hide();
-        }, duration);
-      }
-    },
-    hide() {
-      const { onClose } = this.data;
-      clearTimeout(this.timer);
-      this.setData({ show: false });
-      wx.nextTick(onClose);
-    },
-    onTap(event) {
-      const { onClick } = this.data;
-      if (onClick) {
-        onClick(event.detail);
-      }
-    },
-  },
 });

dist/notify/notify.d.ts

@@ -1,20 +1,20 @@
 interface NotifyOptions {
-  type?: 'primary' | 'success' | 'danger' | 'warning';
+    type?: 'primary' | 'success' | 'danger' | 'warning';
-  color?: string;
+    color?: string;
-  zIndex?: number;
+    zIndex?: number;
-  top?: number;
+    top?: number;
-  message: string;
+    message: string;
-  context?: any;
+    context?: any;
-  duration?: number;
+    duration?: number;
-  selector?: string;
+    selector?: string;
-  background?: string;
+    background?: string;
-  safeAreaInsetTop?: boolean;
+    safeAreaInsetTop?: boolean;
-  onClick?: () => void;
+    onClick?: () => void;
-  onOpened?: () => void;
+    onOpened?: () => void;
-  onClose?: () => void;
+    onClose?: () => void;
 }
 declare function Notify(options: NotifyOptions | string): any;
 declare namespace Notify {
-  var clear: (options?: NotifyOptions | undefined) => void;
+    var clear: (options?: NotifyOptions | undefined) => void;
 }
 export default Notify;

dist/notify/notify.js

@@ -1,52 +1,46 @@
 import { WHITE } from '../common/color';
 const defaultOptions = {
-  selector: '#van-notify',
+    selector: '#van-notify',
-  type: 'danger',
+    type: 'danger',
-  message: '',
+    message: '',
-  background: '',
+    background: '',
-  duration: 3000,
+    duration: 3000,
-  zIndex: 110,
+    zIndex: 110,
-  top: 0,
+    top: 0,
-  color: WHITE,
+    color: WHITE,
-  safeAreaInsetTop: false,
+    safeAreaInsetTop: false,
-  onClick: () => {},
+    onClick: () => { },
-  onOpened: () => {},
+    onOpened: () => { },
-  onClose: () => {},
+    onClose: () => { },
 };
 function parseOptions(message) {
-  if (message == null) {
+    if (message == null) {
-    return {};
+        return {};
-  }
+    }
-  return typeof message === 'string' ? { message } : message;
+    return typeof message === 'string' ? { message } : message;
 }
 function getContext() {
-  const pages = getCurrentPages();
+    const pages = getCurrentPages();
-  return pages[pages.length - 1];
+    return pages[pages.length - 1];
 }
 export default function Notify(options) {
-  options = Object.assign(
+    options = Object.assign(Object.assign({}, defaultOptions), parseOptions(options));
-    Object.assign({}, defaultOptions),
+    const context = options.context || getContext();
-    parseOptions(options)
+    const notify = context.selectComponent(options.selector);
-  );
+    delete options.context;
-  const context = options.context || getContext();
+    delete options.selector;
-  const notify = context.selectComponent(options.selector);
+    if (notify) {
-  delete options.context;
+        notify.setData(options);
-  delete options.selector;
+        notify.show();
-  if (notify) {
+        return notify;
-    notify.setData(options);
+    }
-    notify.show();
+    console.warn('未找到 van-notify 节点，请确认 selector 及 context 是否正确');
-    return notify;
-  }
-  console.warn('未找到 van-notify 节点，请确认 selector 及 context 是否正确');
 }
 Notify.clear = function (options) {
-  options = Object.assign(
+    options = Object.assign(Object.assign({}, defaultOptions), parseOptions(options));
-    Object.assign({}, defaultOptions),
+    const context = options.context || getContext();
-    parseOptions(options)
+    const notify = context.selectComponent(options.selector);
-  );
+    if (notify) {
-  const context = options.context || getContext();
+        notify.hide();
-  const notify = context.selectComponent(options.selector);
+    }
-  if (notify) {
-    notify.hide();
-  }
 };

dist/overlay/index.js

@@ -1,26 +1,26 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    show: Boolean,
+        show: Boolean,
-    customStyle: String,
+        customStyle: String,
-    duration: {
+        duration: {
-      type: null,
+            type: null,
-      value: 300,
+            value: 300,
+        },
+        zIndex: {
+            type: Number,
+            value: 1,
+        },
+        lockScroll: {
+            type: Boolean,
+            value: true,
+        },
     },
-    zIndex: {
+    methods: {
-      type: Number,
+        onClick() {
-      value: 1,
+            this.$emit('click');
+        },
+        // for prevent touchmove
+        noop() { },
     },
-    lockScroll: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  methods: {
-    onClick() {
-      this.$emit('click');
-    },
-    // for prevent touchmove
-    noop() {},
-  },
 });

dist/panel/index.js

@@ -1,9 +1,9 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  classes: ['header-class', 'footer-class'],
+    classes: ['header-class', 'footer-class'],
-  props: {
+    props: {
-    desc: String,
+        desc: String,
-    title: String,
+        title: String,
-    status: String,
+        status: String,
-  },
+    },
 });

dist/picker-column/index.js

@@ -3,122 +3,116 @@ import { range } from '../common/utils';
 import { isObj } from '../common/validator';
 const DEFAULT_DURATION = 200;
 VantComponent({
-  classes: ['active-class'],
+    classes: ['active-class'],
-  props: {
+    props: {
-    valueKey: String,
+        valueKey: String,
-    className: String,
+        className: String,
-    itemHeight: Number,
+        itemHeight: Number,
-    visibleItemCount: Number,
+        visibleItemCount: Number,
-    initialOptions: {
+        initialOptions: {
-      type: Array,
+            type: Array,
-      value: [],
+            value: [],
+        },
+        defaultIndex: {
+            type: Number,
+            value: 0,
+            observer(value) {
+                this.setIndex(value);
+            },
+        },
     },
-    defaultIndex: {
+    data: {
-      type: Number,
+        startY: 0,
-      value: 0,
+        offset: 0,
-      observer(value) {
-        this.setIndex(value);
-      },
-    },
-  },
-  data: {
-    startY: 0,
-    offset: 0,
-    duration: 0,
-    startOffset: 0,
-    options: [],
-    currentIndex: 0,
-  },
-  created() {
-    const { defaultIndex, initialOptions } = this.data;
-    this.set({
-      currentIndex: defaultIndex,
-      options: initialOptions,
-    }).then(() => {
-      this.setIndex(defaultIndex);
-    });
-  },
-  methods: {
-    getCount() {
-      return this.data.options.length;
-    },
-    onTouchStart(event) {
-      this.setData({
-        startY: event.touches[0].clientY,
-        startOffset: this.data.offset,
         duration: 0,
-      });
+        startOffset: 0,
+        options: [],
+        currentIndex: 0,
     },
-    onTouchMove(event) {
+    created() {
-      const { data } = this;
+        const { defaultIndex, initialOptions } = this.data;
-      const deltaY = event.touches[0].clientY - data.startY;
+        this.set({
-      this.setData({
+            currentIndex: defaultIndex,
-        offset: range(
+            options: initialOptions,
-          data.startOffset + deltaY,
+        }).then(() => {
-          -(this.getCount() * data.itemHeight),
+            this.setIndex(defaultIndex);
-          data.itemHeight
-        ),
-      });
-    },
-    onTouchEnd() {
-      const { data } = this;
-      if (data.offset !== data.startOffset) {
-        this.setData({ duration: DEFAULT_DURATION });
-        const index = range(
-          Math.round(-data.offset / data.itemHeight),
-          0,
-          this.getCount() - 1
-        );
-        this.setIndex(index, true);
-      }
-    },
-    onClickItem(event) {
-      const { index } = event.currentTarget.dataset;
-      this.setIndex(index, true);
-    },
-    adjustIndex(index) {
-      const { data } = this;
-      const count = this.getCount();
-      index = range(index, 0, count);
-      for (let i = index; i < count; i++) {
-        if (!this.isDisabled(data.options[i])) return i;
-      }
-      for (let i = index - 1; i >= 0; i--) {
-        if (!this.isDisabled(data.options[i])) return i;
-      }
-    },
-    isDisabled(option) {
-      return isObj(option) && option.disabled;
-    },
-    getOptionText(option) {
-      const { data } = this;
-      return isObj(option) && data.valueKey in option
-        ? option[data.valueKey]
-        : option;
-    },
-    setIndex(index, userAction) {
-      const { data } = this;
-      index = this.adjustIndex(index) || 0;
-      const offset = -index * data.itemHeight;
-      if (index !== data.currentIndex) {
-        return this.set({ offset, currentIndex: index }).then(() => {
-          userAction && this.$emit('change', index);
         });
-      }
-      return this.set({ offset });
     },
-    setValue(value) {
+    methods: {
-      const { options } = this.data;
+        getCount() {
-      for (let i = 0; i < options.length; i++) {
+            return this.data.options.length;
-        if (this.getOptionText(options[i]) === value) {
+        },
-          return this.setIndex(i);
+        onTouchStart(event) {
-        }
+            this.setData({
-      }
+                startY: event.touches[0].clientY,
-      return Promise.resolve();
+                startOffset: this.data.offset,
+                duration: 0,
+            });
+        },
+        onTouchMove(event) {
+            const { data } = this;
+            const deltaY = event.touches[0].clientY - data.startY;
+            this.setData({
+                offset: range(data.startOffset + deltaY, -(this.getCount() * data.itemHeight), data.itemHeight),
+            });
+        },
+        onTouchEnd() {
+            const { data } = this;
+            if (data.offset !== data.startOffset) {
+                this.setData({ duration: DEFAULT_DURATION });
+                const index = range(Math.round(-data.offset / data.itemHeight), 0, this.getCount() - 1);
+                this.setIndex(index, true);
+            }
+        },
+        onClickItem(event) {
+            const { index } = event.currentTarget.dataset;
+            this.setIndex(index, true);
+        },
+        adjustIndex(index) {
+            const { data } = this;
+            const count = this.getCount();
+            index = range(index, 0, count);
+            for (let i = index; i < count; i++) {
+                if (!this.isDisabled(data.options[i]))
+                    return i;
+            }
+            for (let i = index - 1; i >= 0; i--) {
+                if (!this.isDisabled(data.options[i]))
+                    return i;
+            }
+        },
+        isDisabled(option) {
+            return isObj(option) && option.disabled;
+        },
+        getOptionText(option) {
+            const { data } = this;
+            return isObj(option) && data.valueKey in option
+                ? option[data.valueKey]
+                : option;
+        },
+        setIndex(index, userAction) {
+            const { data } = this;
+            index = this.adjustIndex(index) || 0;
+            const offset = -index * data.itemHeight;
+            if (index !== data.currentIndex) {
+                return this.set({ offset, currentIndex: index }).then(() => {
+                    userAction && this.$emit('change', index);
+                });
+            }
+            return this.set({ offset });
+        },
+        setValue(value) {
+            const { options } = this.data;
+            for (let i = 0; i < options.length; i++) {
+                if (this.getOptionText(options[i]) === value) {
+                    return this.setIndex(i);
+                }
+            }
+            return Promise.resolve();
+        },
+        getValue() {
+            const { data } = this;
+            return data.options[data.currentIndex];
+        },
     },
-    getValue() {
-      const { data } = this;
-      return data.options[data.currentIndex];
-    },
-  },
 });

dist/picker/index.js

@@ -1,146 +1,136 @@
 import { VantComponent } from '../common/component';
 import { pickerProps } from './shared';
 VantComponent({
-  classes: ['active-class', 'toolbar-class', 'column-class'],
+    classes: ['active-class', 'toolbar-class', 'column-class'],
-  props: Object.assign(Object.assign({}, pickerProps), {
+    props: Object.assign(Object.assign({}, pickerProps), { valueKey: {
-    valueKey: {
+            type: String,
-      type: String,
+            value: 'text',
-      value: 'text',
+        }, toolbarPosition: {
-    },
+            type: String,
-    toolbarPosition: {
+            value: 'top',
-      type: String,
+        }, defaultIndex: {
-      value: 'top',
+            type: Number,
-    },
+            value: 0,
-    defaultIndex: {
+        }, columns: {
-      type: Number,
+            type: Array,
-      value: 0,
+            value: [],
-    },
+            observer(columns = []) {
-    columns: {
+                this.simple = columns.length && !columns[0].values;
-      type: Array,
+                if (Array.isArray(this.children) && this.children.length) {
-      value: [],
+                    this.setColumns().catch(() => { });
-      observer(columns = []) {
+                }
-        this.simple = columns.length && !columns[0].values;
+            },
-        if (Array.isArray(this.children) && this.children.length) {
+        } }),
-          this.setColumns().catch(() => {});
+    beforeCreate() {
-        }
+        Object.defineProperty(this, 'children', {
-      },
+            get: () => this.selectAllComponents('.van-picker__column') || [],
-    },
-  }),
-  beforeCreate() {
-    Object.defineProperty(this, 'children', {
-      get: () => this.selectAllComponents('.van-picker__column') || [],
-    });
-  },
-  methods: {
-    noop() {},
-    setColumns() {
-      const { data } = this;
-      const columns = this.simple ? [{ values: data.columns }] : data.columns;
-      const stack = columns.map((column, index) =>
-        this.setColumnValues(index, column.values)
-      );
-      return Promise.all(stack);
-    },
-    emit(event) {
-      const { type } = event.currentTarget.dataset;
-      if (this.simple) {
-        this.$emit(type, {
-          value: this.getColumnValue(0),
-          index: this.getColumnIndex(0),
         });
-      } else {
-        this.$emit(type, {
-          value: this.getValues(),
-          index: this.getIndexes(),
-        });
-      }
     },
-    onChange(event) {
+    methods: {
-      if (this.simple) {
+        noop() { },
-        this.$emit('change', {
+        setColumns() {
-          picker: this,
+            const { data } = this;
-          value: this.getColumnValue(0),
+            const columns = this.simple ? [{ values: data.columns }] : data.columns;
-          index: this.getColumnIndex(0),
+            const stack = columns.map((column, index) => this.setColumnValues(index, column.values));
-        });
+            return Promise.all(stack);
-      } else {
+        },
-        this.$emit('change', {
+        emit(event) {
-          picker: this,
+            const { type } = event.currentTarget.dataset;
-          value: this.getValues(),
+            if (this.simple) {
-          index: event.currentTarget.dataset.index,
+                this.$emit(type, {
-        });
+                    value: this.getColumnValue(0),
-      }
+                    index: this.getColumnIndex(0),
+                });
+            }
+            else {
+                this.$emit(type, {
+                    value: this.getValues(),
+                    index: this.getIndexes(),
+                });
+            }
+        },
+        onChange(event) {
+            if (this.simple) {
+                this.$emit('change', {
+                    picker: this,
+                    value: this.getColumnValue(0),
+                    index: this.getColumnIndex(0),
+                });
+            }
+            else {
+                this.$emit('change', {
+                    picker: this,
+                    value: this.getValues(),
+                    index: event.currentTarget.dataset.index,
+                });
+            }
+        },
+        // get column instance by index
+        getColumn(index) {
+            return this.children[index];
+        },
+        // get column value by index
+        getColumnValue(index) {
+            const column = this.getColumn(index);
+            return column && column.getValue();
+        },
+        // set column value by index
+        setColumnValue(index, value) {
+            const column = this.getColumn(index);
+            if (column == null) {
+                return Promise.reject(new Error('setColumnValue: 对应列不存在'));
+            }
+            return column.setValue(value);
+        },
+        // get column option index by column index
+        getColumnIndex(columnIndex) {
+            return (this.getColumn(columnIndex) || {}).data.currentIndex;
+        },
+        // set column option index by column index
+        setColumnIndex(columnIndex, optionIndex) {
+            const column = this.getColumn(columnIndex);
+            if (column == null) {
+                return Promise.reject(new Error('setColumnIndex: 对应列不存在'));
+            }
+            return column.setIndex(optionIndex);
+        },
+        // get options of column by index
+        getColumnValues(index) {
+            return (this.children[index] || {}).data.options;
+        },
+        // set options of column by index
+        setColumnValues(index, options, needReset = true) {
+            const column = this.children[index];
+            if (column == null) {
+                return Promise.reject(new Error('setColumnValues: 对应列不存在'));
+            }
+            const isSame = JSON.stringify(column.data.options) === JSON.stringify(options);
+            if (isSame) {
+                return Promise.resolve();
+            }
+            return column.set({ options }).then(() => {
+                if (needReset) {
+                    column.setIndex(0);
+                }
+            });
+        },
+        // get values of all columns
+        getValues() {
+            return this.children.map((child) => child.getValue());
+        },
+        // set values of all columns
+        setValues(values) {
+            const stack = values.map((value, index) => this.setColumnValue(index, value));
+            return Promise.all(stack);
+        },
+        // get indexes of all columns
+        getIndexes() {
+            return this.children.map((child) => child.data.currentIndex);
+        },
+        // set indexes of all columns
+        setIndexes(indexes) {
+            const stack = indexes.map((optionIndex, columnIndex) => this.setColumnIndex(columnIndex, optionIndex));
+            return Promise.all(stack);
+        },
     },
-    // get column instance by index
-    getColumn(index) {
-      return this.children[index];
-    },
-    // get column value by index
-    getColumnValue(index) {
-      const column = this.getColumn(index);
-      return column && column.getValue();
-    },
-    // set column value by index
-    setColumnValue(index, value) {
-      const column = this.getColumn(index);
-      if (column == null) {
-        return Promise.reject(new Error('setColumnValue: 对应列不存在'));
-      }
-      return column.setValue(value);
-    },
-    // get column option index by column index
-    getColumnIndex(columnIndex) {
-      return (this.getColumn(columnIndex) || {}).data.currentIndex;
-    },
-    // set column option index by column index
-    setColumnIndex(columnIndex, optionIndex) {
-      const column = this.getColumn(columnIndex);
-      if (column == null) {
-        return Promise.reject(new Error('setColumnIndex: 对应列不存在'));
-      }
-      return column.setIndex(optionIndex);
-    },
-    // get options of column by index
-    getColumnValues(index) {
-      return (this.children[index] || {}).data.options;
-    },
-    // set options of column by index
-    setColumnValues(index, options, needReset = true) {
-      const column = this.children[index];
-      if (column == null) {
-        return Promise.reject(new Error('setColumnValues: 对应列不存在'));
-      }
-      const isSame =
-        JSON.stringify(column.data.options) === JSON.stringify(options);
-      if (isSame) {
-        return Promise.resolve();
-      }
-      return column.set({ options }).then(() => {
-        if (needReset) {
-          column.setIndex(0);
-        }
-      });
-    },
-    // get values of all columns
-    getValues() {
-      return this.children.map((child) => child.getValue());
-    },
-    // set values of all columns
-    setValues(values) {
-      const stack = values.map((value, index) =>
-        this.setColumnValue(index, value)
-      );
-      return Promise.all(stack);
-    },
-    // get indexes of all columns
-    getIndexes() {
-      return this.children.map((child) => child.data.currentIndex);
-    },
-    // set indexes of all columns
-    setIndexes(indexes) {
-      const stack = indexes.map((optionIndex, columnIndex) =>
-        this.setColumnIndex(columnIndex, optionIndex)
-      );
-      return Promise.all(stack);
-    },
-  },
 });

dist/picker/shared.js

@@ -1,21 +1,21 @@
 export const pickerProps = {
-  title: String,
+    title: String,
-  loading: Boolean,
+    loading: Boolean,
-  showToolbar: Boolean,
+    showToolbar: Boolean,
-  cancelButtonText: {
+    cancelButtonText: {
-    type: String,
+        type: String,
-    value: '取消',
+        value: '取消',
-  },
+    },
-  confirmButtonText: {
+    confirmButtonText: {
-    type: String,
+        type: String,
-    value: '确认',
+        value: '确认',
-  },
+    },
-  visibleItemCount: {
+    visibleItemCount: {
-    type: Number,
+        type: Number,
-    value: 6,
+        value: 6,
-  },
+    },
-  itemHeight: {
+    itemHeight: {
-    type: Number,
+        type: Number,
-    value: 44,
+        value: 44,
-  },
+    },
 };

dist/popup/index.js

@@ -1,88 +1,89 @@
 import { VantComponent } from '../common/component';
 import { transition } from '../mixins/transition';
 VantComponent({
-  classes: [
+    classes: [
-    'enter-class',
+        'enter-class',
-    'enter-active-class',
+        'enter-active-class',
-    'enter-to-class',
+        'enter-to-class',
-    'leave-class',
+        'leave-class',
-    'leave-active-class',
+        'leave-active-class',
-    'leave-to-class',
+        'leave-to-class',
-    'close-icon-class',
+        'close-icon-class',
-  ],
+    ],
-  mixins: [transition(false)],
+    mixins: [transition(false)],
-  props: {
+    props: {
-    round: Boolean,
+        round: Boolean,
-    closeable: Boolean,
+        closeable: Boolean,
-    customStyle: String,
+        customStyle: String,
-    overlayStyle: String,
+        overlayStyle: String,
-    transition: {
+        transition: {
-      type: String,
+            type: String,
-      observer: 'observeClass',
+            observer: 'observeClass',
+        },
+        zIndex: {
+            type: Number,
+            value: 100,
+        },
+        overlay: {
+            type: Boolean,
+            value: true,
+        },
+        closeIcon: {
+            type: String,
+            value: 'cross',
+        },
+        closeIconPosition: {
+            type: String,
+            value: 'top-right',
+        },
+        closeOnClickOverlay: {
+            type: Boolean,
+            value: true,
+        },
+        position: {
+            type: String,
+            value: 'center',
+            observer: 'observeClass',
+        },
+        safeAreaInsetBottom: {
+            type: Boolean,
+            value: true,
+        },
+        safeAreaInsetTop: {
+            type: Boolean,
+            value: false,
+        },
+        lockScroll: {
+            type: Boolean,
+            value: true,
+        },
     },
-    zIndex: {
+    created() {
-      type: Number,
+        this.observeClass();
-      value: 100,
     },
-    overlay: {
+    methods: {
-      type: Boolean,
+        onClickCloseIcon() {
-      value: true,
+            this.$emit('close');
+        },
+        onClickOverlay() {
+            this.$emit('click-overlay');
+            if (this.data.closeOnClickOverlay) {
+                this.$emit('close');
+            }
+        },
+        observeClass() {
+            const { transition, position, duration } = this.data;
+            const updateData = {
+                name: transition || position,
+            };
+            if (transition === 'none') {
+                updateData.duration = 0;
+                this.originDuration = duration;
+            }
+            else if (this.originDuration != null) {
+                updateData.duration = this.originDuration;
+            }
+            this.setData(updateData);
+        },
     },
-    closeIcon: {
-      type: String,
-      value: 'cross',
-    },
-    closeIconPosition: {
-      type: String,
-      value: 'top-right',
-    },
-    closeOnClickOverlay: {
-      type: Boolean,
-      value: true,
-    },
-    position: {
-      type: String,
-      value: 'center',
-      observer: 'observeClass',
-    },
-    safeAreaInsetBottom: {
-      type: Boolean,
-      value: true,
-    },
-    safeAreaInsetTop: {
-      type: Boolean,
-      value: false,
-    },
-    lockScroll: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  created() {
-    this.observeClass();
-  },
-  methods: {
-    onClickCloseIcon() {
-      this.$emit('close');
-    },
-    onClickOverlay() {
-      this.$emit('click-overlay');
-      if (this.data.closeOnClickOverlay) {
-        this.$emit('close');
-      }
-    },
-    observeClass() {
-      const { transition, position, duration } = this.data;
-      const updateData = {
-        name: transition || position,
-      };
-      if (transition === 'none') {
-        updateData.duration = 0;
-        this.originDuration = duration;
-      } else if (this.originDuration != null) {
-        updateData.duration = this.originDuration;
-      }
-      this.setData(updateData);
-    },
-  },
 });

dist/progress/index.js

@@ -2,50 +2,50 @@ import { VantComponent } from '../common/component';
 import { BLUE } from '../common/color';
 import { getRect } from '../common/utils';
 VantComponent({
-  props: {
+    props: {
-    inactive: Boolean,
+        inactive: Boolean,
-    percentage: {
+        percentage: {
-      type: Number,
+            type: Number,
-      observer: 'setLeft',
+            observer: 'setLeft',
+        },
+        pivotText: String,
+        pivotColor: String,
+        trackColor: String,
+        showPivot: {
+            type: Boolean,
+            value: true,
+        },
+        color: {
+            type: String,
+            value: BLUE,
+        },
+        textColor: {
+            type: String,
+            value: '#fff',
+        },
+        strokeWidth: {
+            type: null,
+            value: 4,
+        },
     },
-    pivotText: String,
+    data: {
-    pivotColor: String,
+        right: 0,
-    trackColor: String,
-    showPivot: {
-      type: Boolean,
-      value: true,
     },
-    color: {
+    mounted() {
-      type: String,
+        this.setLeft();
-      value: BLUE,
     },
-    textColor: {
+    methods: {
-      type: String,
+        setLeft() {
-      value: '#fff',
+            Promise.all([
+                getRect(this, '.van-progress'),
+                getRect(this, '.van-progress__pivot'),
+            ]).then(([portion, pivot]) => {
+                if (portion && pivot) {
+                    this.setData({
+                        right: (pivot.width * (this.data.percentage - 100)) / 100,
+                    });
+                }
+            });
+        },
     },
-    strokeWidth: {
-      type: null,
-      value: 4,
-    },
-  },
-  data: {
-    right: 0,
-  },
-  mounted() {
-    this.setLeft();
-  },
-  methods: {
-    setLeft() {
-      Promise.all([
-        getRect(this, '.van-progress'),
-        getRect(this, '.van-progress__pivot'),
-      ]).then(([portion, pivot]) => {
-        if (portion && pivot) {
-          this.setData({
-            right: (pivot.width * (this.data.percentage - 100)) / 100,
-          });
-        }
-      });
-    },
-  },
 });

dist/radio-group/index.js

@@ -1,22 +1,22 @@
 import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 VantComponent({
-  field: true,
+    field: true,
-  relation: useChildren('radio'),
+    relation: useChildren('radio'),
-  props: {
+    props: {
-    value: {
+        value: {
-      type: null,
+            type: null,
-      observer: 'updateChildren',
+            observer: 'updateChildren',
+        },
+        direction: String,
+        disabled: {
+            type: Boolean,
+            observer: 'updateChildren',
+        },
     },
-    direction: String,
+    methods: {
-    disabled: {
+        updateChildren() {
-      type: Boolean,
+            this.children.forEach((child) => child.updateFromParent());
-      observer: 'updateChildren',
+        },
     },
-  },
-  methods: {
-    updateChildren() {
-      this.children.forEach((child) => child.updateFromParent());
-    },
-  },
 });

dist/radio/index.js

@@ -2,65 +2,65 @@ import { canIUseModel } from '../common/version';
 import { VantComponent } from '../common/component';
 import { useParent } from '../common/relation';
 VantComponent({
-  field: true,
+    field: true,
-  relation: useParent('radio-group', function () {
+    relation: useParent('radio-group', function () {
-    this.updateFromParent();
+        this.updateFromParent();
-  }),
+    }),
-  classes: ['icon-class', 'label-class'],
+    classes: ['icon-class', 'label-class'],
-  props: {
+    props: {
-    name: null,
+        name: null,
-    value: null,
+        value: null,
-    disabled: Boolean,
+        disabled: Boolean,
-    useIconSlot: Boolean,
+        useIconSlot: Boolean,
-    checkedColor: String,
+        checkedColor: String,
-    labelPosition: {
+        labelPosition: {
-      type: String,
+            type: String,
-      value: 'right',
+            value: 'right',
+        },
+        labelDisabled: Boolean,
+        shape: {
+            type: String,
+            value: 'round',
+        },
+        iconSize: {
+            type: null,
+            value: 20,
+        },
     },
-    labelDisabled: Boolean,
+    data: {
-    shape: {
+        direction: '',
-      type: String,
+        parentDisabled: false,
-      value: 'round',
     },
-    iconSize: {
+    methods: {
-      type: null,
+        updateFromParent() {
-      value: 20,
+            if (!this.parent) {
+                return;
+            }
+            const { value, disabled: parentDisabled, direction } = this.parent.data;
+            this.setData({
+                value,
+                direction,
+                parentDisabled,
+            });
+        },
+        emitChange(value) {
+            const instance = this.parent || this;
+            instance.$emit('input', value);
+            instance.$emit('change', value);
+            if (canIUseModel()) {
+                instance.setData({ value });
+            }
+        },
+        onChange() {
+            if (!this.data.disabled && !this.data.parentDisabled) {
+                this.emitChange(this.data.name);
+            }
+        },
+        onClickLabel() {
+            const { disabled, parentDisabled, labelDisabled, name } = this.data;
+            if (!(disabled || parentDisabled) && !labelDisabled) {
+                this.emitChange(name);
+            }
+        },
     },
-  },
-  data: {
-    direction: '',
-    parentDisabled: false,
-  },
-  methods: {
-    updateFromParent() {
-      if (!this.parent) {
-        return;
-      }
-      const { value, disabled: parentDisabled, direction } = this.parent.data;
-      this.setData({
-        value,
-        direction,
-        parentDisabled,
-      });
-    },
-    emitChange(value) {
-      const instance = this.parent || this;
-      instance.$emit('input', value);
-      instance.$emit('change', value);
-      if (canIUseModel()) {
-        instance.setData({ value });
-      }
-    },
-    onChange() {
-      if (!this.data.disabled && !this.data.parentDisabled) {
-        this.emitChange(this.data.name);
-      }
-    },
-    onClickLabel() {
-      const { disabled, parentDisabled, labelDisabled, name } = this.data;
-      if (!(disabled || parentDisabled) && !labelDisabled) {
-        this.emitChange(name);
-      }
-    },
-  },
 });

dist/rate/index.js

@@ -2,78 +2,77 @@ import { getAllRect } from '../common/utils';
 import { VantComponent } from '../common/component';
 import { canIUseModel } from '../common/version';
 VantComponent({
-  field: true,
+    field: true,
-  classes: ['icon-class'],
+    classes: ['icon-class'],
-  props: {
+    props: {
-    value: {
+        value: {
-      type: Number,
+            type: Number,
-      observer(value) {
+            observer(value) {
-        if (value !== this.data.innerValue) {
+                if (value !== this.data.innerValue) {
-          this.setData({ innerValue: value });
+                    this.setData({ innerValue: value });
-        }
+                }
-      },
+            },
+        },
+        readonly: Boolean,
+        disabled: Boolean,
+        allowHalf: Boolean,
+        size: null,
+        icon: {
+            type: String,
+            value: 'star',
+        },
+        voidIcon: {
+            type: String,
+            value: 'star-o',
+        },
+        color: String,
+        voidColor: String,
+        disabledColor: String,
+        count: {
+            type: Number,
+            value: 5,
+            observer(value) {
+                this.setData({ innerCountArray: Array.from({ length: value }) });
+            },
+        },
+        gutter: null,
+        touchable: {
+            type: Boolean,
+            value: true,
+        },
     },
-    readonly: Boolean,
+    data: {
-    disabled: Boolean,
+        innerValue: 0,
-    allowHalf: Boolean,
+        innerCountArray: Array.from({ length: 5 }),
-    size: null,
-    icon: {
-      type: String,
-      value: 'star',
     },
-    voidIcon: {
+    methods: {
-      type: String,
+        onSelect(event) {
-      value: 'star-o',
+            const { data } = this;
+            const { score } = event.currentTarget.dataset;
+            if (!data.disabled && !data.readonly) {
+                this.setData({ innerValue: score + 1 });
+                if (canIUseModel()) {
+                    this.setData({ value: score + 1 });
+                }
+                wx.nextTick(() => {
+                    this.$emit('input', score + 1);
+                    this.$emit('change', score + 1);
+                });
+            }
+        },
+        onTouchMove(event) {
+            const { touchable } = this.data;
+            if (!touchable)
+                return;
+            const { clientX } = event.touches[0];
+            getAllRect(this, '.van-rate__icon').then((list) => {
+                const target = list
+                    .sort((cur, next) => cur.dataset.score - next.dataset.score)
+                    .find((item) => clientX >= item.left && clientX <= item.right);
+                if (target != null) {
+                    this.onSelect(Object.assign(Object.assign({}, event), { currentTarget: target }));
+                }
+            });
+        },
     },
-    color: String,
-    voidColor: String,
-    disabledColor: String,
-    count: {
-      type: Number,
-      value: 5,
-      observer(value) {
-        this.setData({ innerCountArray: Array.from({ length: value }) });
-      },
-    },
-    gutter: null,
-    touchable: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    innerValue: 0,
-    innerCountArray: Array.from({ length: 5 }),
-  },
-  methods: {
-    onSelect(event) {
-      const { data } = this;
-      const { score } = event.currentTarget.dataset;
-      if (!data.disabled && !data.readonly) {
-        this.setData({ innerValue: score + 1 });
-        if (canIUseModel()) {
-          this.setData({ value: score + 1 });
-        }
-        wx.nextTick(() => {
-          this.$emit('input', score + 1);
-          this.$emit('change', score + 1);
-        });
-      }
-    },
-    onTouchMove(event) {
-      const { touchable } = this.data;
-      if (!touchable) return;
-      const { clientX } = event.touches[0];
-      getAllRect(this, '.van-rate__icon').then((list) => {
-        const target = list
-          .sort((cur, next) => cur.dataset.score - next.dataset.score)
-          .find((item) => clientX >= item.left && clientX <= item.right);
-        if (target != null) {
-          this.onSelect(
-            Object.assign(Object.assign({}, event), { currentTarget: target })
-          );
-        }
-      });
-    },
-  },
 });

dist/row/index.js

@@ -1,23 +1,23 @@
 import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 VantComponent({
-  relation: useChildren('col', function (target) {
+    relation: useChildren('col', function (target) {
-    const { gutter } = this.data;
+        const { gutter } = this.data;
-    if (gutter) {
+        if (gutter) {
-      target.setData({ gutter });
+            target.setData({ gutter });
-    }
+        }
-  }),
+    }),
-  props: {
+    props: {
-    gutter: {
+        gutter: {
-      type: Number,
+            type: Number,
-      observer: 'setGutter',
+            observer: 'setGutter',
+        },
     },
-  },
+    methods: {
-  methods: {
+        setGutter() {
-    setGutter() {
+            this.children.forEach((col) => {
-      this.children.forEach((col) => {
+                col.setData(this.data);
-        col.setData(this.data);
+            });
-      });
+        },
     },
-  },
 });

dist/search/index.js

@@ -1,89 +1,89 @@
 import { VantComponent } from '../common/component';
 import { canIUseModel } from '../common/version';
 VantComponent({
-  field: true,
+    field: true,
-  classes: ['field-class', 'input-class', 'cancel-class'],
+    classes: ['field-class', 'input-class', 'cancel-class'],
-  props: {
+    props: {
-    label: String,
+        label: String,
-    focus: Boolean,
+        focus: Boolean,
-    error: Boolean,
+        error: Boolean,
-    disabled: Boolean,
+        disabled: Boolean,
-    readonly: Boolean,
+        readonly: Boolean,
-    inputAlign: String,
+        inputAlign: String,
-    showAction: Boolean,
+        showAction: Boolean,
-    useActionSlot: Boolean,
+        useActionSlot: Boolean,
-    useLeftIconSlot: Boolean,
+        useLeftIconSlot: Boolean,
-    useRightIconSlot: Boolean,
+        useRightIconSlot: Boolean,
-    leftIcon: {
+        leftIcon: {
-      type: String,
+            type: String,
-      value: 'search',
+            value: 'search',
+        },
+        rightIcon: String,
+        placeholder: String,
+        placeholderStyle: String,
+        actionText: {
+            type: String,
+            value: '取消',
+        },
+        background: {
+            type: String,
+            value: '#ffffff',
+        },
+        maxlength: {
+            type: Number,
+            value: -1,
+        },
+        shape: {
+            type: String,
+            value: 'square',
+        },
+        clearable: {
+            type: Boolean,
+            value: true,
+        },
+        clearTrigger: {
+            type: String,
+            value: 'focus',
+        },
+        clearIcon: {
+            type: String,
+            value: 'clear',
+        },
     },
-    rightIcon: String,
+    methods: {
-    placeholder: String,
+        onChange(event) {
-    placeholderStyle: String,
+            if (canIUseModel()) {
-    actionText: {
+                this.setData({ value: event.detail });
-      type: String,
+            }
-      value: '取消',
+            this.$emit('change', event.detail);
+        },
+        onCancel() {
+            /**
+             * 修复修改输入框值时，输入框失焦和赋值同时触发，赋值失效
+             * https://github.com/youzan/@vant/weapp/issues/1768
+             */
+            setTimeout(() => {
+                if (canIUseModel()) {
+                    this.setData({ value: '' });
+                }
+                this.$emit('cancel');
+                this.$emit('change', '');
+            }, 200);
+        },
+        onSearch(event) {
+            this.$emit('search', event.detail);
+        },
+        onFocus(event) {
+            this.$emit('focus', event.detail);
+        },
+        onBlur(event) {
+            this.$emit('blur', event.detail);
+        },
+        onClear(event) {
+            this.$emit('clear', event.detail);
+        },
+        onClickInput(event) {
+            this.$emit('click-input', event.detail);
+        },
     },
-    background: {
-      type: String,
-      value: '#ffffff',
-    },
-    maxlength: {
-      type: Number,
-      value: -1,
-    },
-    shape: {
-      type: String,
-      value: 'square',
-    },
-    clearable: {
-      type: Boolean,
-      value: true,
-    },
-    clearTrigger: {
-      type: String,
-      value: 'focus',
-    },
-    clearIcon: {
-      type: String,
-      value: 'clear',
-    },
-  },
-  methods: {
-    onChange(event) {
-      if (canIUseModel()) {
-        this.setData({ value: event.detail });
-      }
-      this.$emit('change', event.detail);
-    },
-    onCancel() {
-      /**
-       * 修复修改输入框值时，输入框失焦和赋值同时触发，赋值失效
-       * https://github.com/youzan/@vant/weapp/issues/1768
-       */
-      setTimeout(() => {
-        if (canIUseModel()) {
-          this.setData({ value: '' });
-        }
-        this.$emit('cancel');
-        this.$emit('change', '');
-      }, 200);
-    },
-    onSearch(event) {
-      this.$emit('search', event.detail);
-    },
-    onFocus(event) {
-      this.$emit('focus', event.detail);
-    },
-    onBlur(event) {
-      this.$emit('blur', event.detail);
-    },
-    onClear(event) {
-      this.$emit('clear', event.detail);
-    },
-    onClickInput(event) {
-      this.$emit('click-input', event.detail);
-    },
-  },
 });

dist/share-sheet/index.js

@@ -1,55 +1,55 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    // whether to show popup
+        // whether to show popup
-    show: Boolean,
+        show: Boolean,
-    // overlay custom style
+        // overlay custom style
-    overlayStyle: String,
+        overlayStyle: String,
-    // z-index
+        // z-index
-    zIndex: {
+        zIndex: {
-      type: Number,
+            type: Number,
-      value: 100,
+            value: 100,
+        },
+        title: String,
+        cancelText: {
+            type: String,
+            value: '取消',
+        },
+        description: String,
+        options: {
+            type: Array,
+            value: [],
+        },
+        overlay: {
+            type: Boolean,
+            value: true,
+        },
+        safeAreaInsetBottom: {
+            type: Boolean,
+            value: true,
+        },
+        closeOnClickOverlay: {
+            type: Boolean,
+            value: true,
+        },
+        duration: {
+            type: null,
+            value: 300,
+        },
     },
-    title: String,
+    methods: {
-    cancelText: {
+        onClickOverlay() {
-      type: String,
+            this.$emit('click-overlay');
-      value: '取消',
+        },
+        onCancel() {
+            this.onClose();
+            this.$emit('cancel');
+        },
+        onSelect(event) {
+            this.$emit('select', event.detail);
+        },
+        onClose() {
+            this.$emit('close');
+        },
     },
-    description: String,
-    options: {
-      type: Array,
-      value: [],
-    },
-    overlay: {
-      type: Boolean,
-      value: true,
-    },
-    safeAreaInsetBottom: {
-      type: Boolean,
-      value: true,
-    },
-    closeOnClickOverlay: {
-      type: Boolean,
-      value: true,
-    },
-    duration: {
-      type: null,
-      value: 300,
-    },
-  },
-  methods: {
-    onClickOverlay() {
-      this.$emit('click-overlay');
-    },
-    onCancel() {
-      this.onClose();
-      this.$emit('cancel');
-    },
-    onSelect(event) {
-      this.$emit('select', event.detail);
-    },
-    onClose() {
-      this.$emit('close');
-    },
-  },
 });

dist/share-sheet/options.js

@@ -1,14 +1,14 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    options: Array,
+        options: Array,
-    showBorder: Boolean,
+        showBorder: Boolean,
-  },
+    },
-  methods: {
+    methods: {
-    onSelect(event) {
+        onSelect(event) {
-      const { index } = event.currentTarget.dataset;
+            const { index } = event.currentTarget.dataset;
-      const option = this.data.options[index];
+            const option = this.data.options[index];
-      this.$emit('select', Object.assign(Object.assign({}, option), { index }));
+            this.$emit('select', Object.assign(Object.assign({}, option), { index }));
+        },
     },
-  },
 });

dist/sidebar-item/index.js

@@ -1,29 +1,29 @@
 import { VantComponent } from '../common/component';
 import { useParent } from '../common/relation';
 VantComponent({
-  classes: ['active-class', 'disabled-class'],
+    classes: ['active-class', 'disabled-class'],
-  relation: useParent('sidebar'),
+    relation: useParent('sidebar'),
-  props: {
+    props: {
-    dot: Boolean,
+        dot: Boolean,
-    badge: null,
+        badge: null,
-    info: null,
+        info: null,
-    title: String,
+        title: String,
-    disabled: Boolean,
+        disabled: Boolean,
-  },
-  methods: {
-    onClick() {
-      const { parent } = this;
-      if (!parent || this.data.disabled) {
-        return;
-      }
-      const index = parent.children.indexOf(this);
-      parent.setActive(index).then(() => {
-        this.$emit('click', index);
-        parent.$emit('change', index);
-      });
     },
-    setActive(selected) {
+    methods: {
-      return this.setData({ selected });
+        onClick() {
+            const { parent } = this;
+            if (!parent || this.data.disabled) {
+                return;
+            }
+            const index = parent.children.indexOf(this);
+            parent.setActive(index).then(() => {
+                this.$emit('click', index);
+                parent.$emit('change', index);
+            });
+        },
+        setActive(selected) {
+            return this.setData({ selected });
+        },
     },
-  },
 });

dist/sidebar/index.js

@@ -1,34 +1,34 @@
 import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 VantComponent({
-  relation: useChildren('sidebar-item', function () {
+    relation: useChildren('sidebar-item', function () {
-    this.setActive(this.data.activeKey);
+        this.setActive(this.data.activeKey);
-  }),
+    }),
-  props: {
+    props: {
-    activeKey: {
+        activeKey: {
-      type: Number,
+            type: Number,
-      value: 0,
+            value: 0,
-      observer: 'setActive',
+            observer: 'setActive',
+        },
     },
-  },
+    beforeCreate() {
-  beforeCreate() {
+        this.currentActive = -1;
-    this.currentActive = -1;
+    },
-  },
+    methods: {
-  methods: {
+        setActive(activeKey) {
-    setActive(activeKey) {
+            const { children, currentActive } = this;
-      const { children, currentActive } = this;
+            if (!children.length) {
-      if (!children.length) {
+                return Promise.resolve();
-        return Promise.resolve();
+            }
-      }
+            this.currentActive = activeKey;
-      this.currentActive = activeKey;
+            const stack = [];
-      const stack = [];
+            if (currentActive !== activeKey && children[currentActive]) {
-      if (currentActive !== activeKey && children[currentActive]) {
+                stack.push(children[currentActive].setActive(false));
-        stack.push(children[currentActive].setActive(false));
+            }
-      }
+            if (children[activeKey]) {
-      if (children[activeKey]) {
+                stack.push(children[activeKey].setActive(true));
-        stack.push(children[activeKey].setActive(true));
+            }
-      }
+            return Promise.all(stack);
-      return Promise.all(stack);
+        },
     },
-  },
 });

dist/skeleton/index.js

@@ -1,46 +1,46 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  classes: ['avatar-class', 'title-class', 'row-class'],
+    classes: ['avatar-class', 'title-class', 'row-class'],
-  props: {
+    props: {
-    row: {
+        row: {
-      type: Number,
+            type: Number,
-      value: 0,
+            value: 0,
-      observer(value) {
+            observer(value) {
-        this.setData({ rowArray: Array.from({ length: value }) });
+                this.setData({ rowArray: Array.from({ length: value }) });
-      },
+            },
+        },
+        title: Boolean,
+        avatar: Boolean,
+        loading: {
+            type: Boolean,
+            value: true,
+        },
+        animate: {
+            type: Boolean,
+            value: true,
+        },
+        avatarSize: {
+            type: String,
+            value: '32px',
+        },
+        avatarShape: {
+            type: String,
+            value: 'round',
+        },
+        titleWidth: {
+            type: String,
+            value: '40%',
+        },
+        rowWidth: {
+            type: null,
+            value: '100%',
+            observer(val) {
+                this.setData({ isArray: val instanceof Array });
+            },
+        },
     },
-    title: Boolean,
+    data: {
-    avatar: Boolean,
+        isArray: false,
-    loading: {
+        rowArray: [],
-      type: Boolean,
-      value: true,
     },
-    animate: {
-      type: Boolean,
-      value: true,
-    },
-    avatarSize: {
-      type: String,
-      value: '32px',
-    },
-    avatarShape: {
-      type: String,
-      value: 'round',
-    },
-    titleWidth: {
-      type: String,
-      value: '40%',
-    },
-    rowWidth: {
-      type: null,
-      value: '100%',
-      observer(val) {
-        this.setData({ isArray: val instanceof Array });
-      },
-    },
-  },
-  data: {
-    isArray: false,
-    rowArray: [],
-  },
 });

dist/slider/index.js

@@ -3,154 +3,162 @@ import { touch } from '../mixins/touch';
 import { canIUseModel } from '../common/version';
 import { getRect } from '../common/utils';
 VantComponent({
-  mixins: [touch],
+    mixins: [touch],
-  props: {
+    props: {
-    range: Boolean,
+        range: Boolean,
-    disabled: Boolean,
+        disabled: Boolean,
-    useButtonSlot: Boolean,
+        useButtonSlot: Boolean,
-    activeColor: String,
+        activeColor: String,
-    inactiveColor: String,
+        inactiveColor: String,
-    max: {
+        max: {
-      type: Number,
+            type: Number,
-      value: 100,
+            value: 100,
+        },
+        min: {
+            type: Number,
+            value: 0,
+        },
+        step: {
+            type: Number,
+            value: 1,
+        },
+        value: {
+            type: null,
+            value: 0,
+            observer(val) {
+                if (val !== this.value) {
+                    this.updateValue(val);
+                }
+            },
+        },
+        barHeight: null,
     },
-    min: {
+    created() {
-      type: Number,
+        this.updateValue(this.data.value);
-      value: 0,
     },
-    step: {
+    methods: {
-      type: Number,
+        onTouchStart(event) {
-      value: 1,
+            if (this.data.disabled)
-    },
+                return;
-    value: {
+            const { index } = event.currentTarget.dataset;
-      type: null,
+            if (typeof index === 'number') {
-      value: 0,
+                this.buttonIndex = index;
-      observer(val) {
+            }
-        if (val !== this.value) {
+            this.touchStart(event);
-          this.updateValue(val);
+            this.startValue = this.format(this.value);
-        }
+            this.newValue = this.value;
-      },
+            if (this.isRange(this.newValue)) {
-    },
+                this.startValue = this.newValue.map((val) => this.format(val));
-    barHeight: null,
+            }
-  },
+            else {
-  created() {
+                this.startValue = this.format(this.newValue);
-    this.updateValue(this.data.value);
+            }
-  },
+            this.dragStatus = 'start';
-  methods: {
+        },
-    onTouchStart(event) {
+        onTouchMove(event) {
-      if (this.data.disabled) return;
+            if (this.data.disabled)
-      const { index } = event.currentTarget.dataset;
+                return;
-      if (typeof index === 'number') {
+            if (this.dragStatus === 'start') {
-        this.buttonIndex = index;
+                this.$emit('drag-start');
-      }
+            }
-      this.touchStart(event);
+            this.touchMove(event);
-      this.startValue = this.format(this.value);
+            this.dragStatus = 'draging';
-      this.newValue = this.value;
+            getRect(this, '.van-slider').then((rect) => {
-      if (this.isRange(this.newValue)) {
+                const diff = (this.deltaX / rect.width) * this.getRange();
-        this.startValue = this.newValue.map((val) => this.format(val));
+                if (this.isRange(this.startValue)) {
-      } else {
+                    this.newValue[this.buttonIndex] =
-        this.startValue = this.format(this.newValue);
+                        this.startValue[this.buttonIndex] + diff;
-      }
+                }
-      this.dragStatus = 'start';
+                else {
-    },
+                    this.newValue = this.startValue + diff;
-    onTouchMove(event) {
+                }
-      if (this.data.disabled) return;
+                this.updateValue(this.newValue, false, true);
-      if (this.dragStatus === 'start') {
+            });
-        this.$emit('drag-start');
+        },
-      }
+        onTouchEnd() {
-      this.touchMove(event);
+            if (this.data.disabled)
-      this.dragStatus = 'draging';
+                return;
-      getRect(this, '.van-slider').then((rect) => {
+            if (this.dragStatus === 'draging') {
-        const diff = (this.deltaX / rect.width) * this.getRange();
+                this.updateValue(this.newValue, true);
-        if (this.isRange(this.startValue)) {
+                this.$emit('drag-end');
-          this.newValue[this.buttonIndex] =
+            }
-            this.startValue[this.buttonIndex] + diff;
+        },
-        } else {
+        onClick(event) {
-          this.newValue = this.startValue + diff;
+            if (this.data.disabled)
-        }
+                return;
-        this.updateValue(this.newValue, false, true);
+            const { min } = this.data;
-      });
+            getRect(this, '.van-slider').then((rect) => {
-    },
+                const value = ((event.detail.x - rect.left) / rect.width) * this.getRange() + min;
-    onTouchEnd() {
+                if (this.isRange(this.value)) {
-      if (this.data.disabled) return;
+                    const [left, right] = this.value;
-      if (this.dragStatus === 'draging') {
+                    const middle = (left + right) / 2;
-        this.updateValue(this.newValue, true);
+                    if (value <= middle) {
-        this.$emit('drag-end');
+                        this.updateValue([value, right], true);
-      }
+                    }
-    },
+                    else {
-    onClick(event) {
+                        this.updateValue([left, value], true);
-      if (this.data.disabled) return;
+                    }
-      const { min } = this.data;
+                }
-      getRect(this, '.van-slider').then((rect) => {
+                else {
-        const value =
+                    this.updateValue(value, true);
-          ((event.detail.x - rect.left) / rect.width) * this.getRange() + min;
+                }
-        if (this.isRange(this.value)) {
+            });
-          const [left, right] = this.value;
+        },
-          const middle = (left + right) / 2;
+        isRange(val) {
-          if (value <= middle) {
+            const { range } = this.data;
-            this.updateValue([value, right], true);
+            return range && Array.isArray(val);
-          } else {
+        },
-            this.updateValue([left, value], true);
+        handleOverlap(value) {
-          }
+            if (value[0] > value[1]) {
-        } else {
+                return value.slice(0).reverse();
-          this.updateValue(value, true);
+            }
-        }
+            return value;
-      });
+        },
-    },
+        updateValue(value, end, drag) {
-    isRange(val) {
+            if (this.isRange(value)) {
-      const { range } = this.data;
+                value = this.handleOverlap(value).map((val) => this.format(val));
-      return range && Array.isArray(val);
+            }
-    },
+            else {
-    handleOverlap(value) {
+                value = this.format(value);
-      if (value[0] > value[1]) {
+            }
-        return value.slice(0).reverse();
+            this.value = value;
-      }
+            this.setData({
-      return value;
+                barStyle: `
-    },
-    updateValue(value, end, drag) {
-      if (this.isRange(value)) {
-        value = this.handleOverlap(value).map((val) => this.format(val));
-      } else {
-        value = this.format(value);
-      }
-      this.value = value;
-      this.setData({
-        barStyle: `
           width: ${this.calcMainAxis()};
           left: ${this.isRange(value) ? `${value[0]}%` : 0};
           ${drag ? 'transition: none;' : ''}
         `,
-      });
+            });
-      if (drag) {
+            if (drag) {
-        this.$emit('drag', { value });
+                this.$emit('drag', { value });
-      }
+            }
-      if (end) {
+            if (end) {
-        this.$emit('change', value);
+                this.$emit('change', value);
-      }
+            }
-      if ((drag || end) && canIUseModel()) {
+            if ((drag || end) && canIUseModel()) {
-        this.setData({ value });
+                this.setData({ value });
-      }
+            }
+        },
+        getScope() {
+            return Number(this.data.max) - Number(this.data.min);
+        },
+        getRange() {
+            const { max, min } = this.data;
+            return max - min;
+        },
+        // 计算选中条的长度百分比
+        calcMainAxis() {
+            const { value } = this;
+            const { min } = this.data;
+            const scope = this.getScope();
+            if (this.isRange(value)) {
+                return `${((value[1] - value[0]) * 100) / scope}%`;
+            }
+            return `${((value - Number(min)) * 100) / scope}%`;
+        },
+        format(value) {
+            const { max, min, step } = this.data;
+            return Math.round(Math.max(min, Math.min(value, max)) / step) * step;
+        },
     },
-    getScope() {
-      return Number(this.data.max) - Number(this.data.min);
-    },
-    getRange() {
-      const { max, min } = this.data;
-      return max - min;
-    },
-    // 计算选中条的长度百分比
-    calcMainAxis() {
-      const { value } = this;
-      const { min } = this.data;
-      const scope = this.getScope();
-      if (this.isRange(value)) {
-        return `${((value[1] - value[0]) * 100) / scope}%`;
-      }
-      return `${((value - Number(min)) * 100) / scope}%`;
-    },
-    format(value) {
-      const { max, min, step } = this.data;
-      return Math.round(Math.max(min, Math.min(value, max)) / step) * step;
-    },
-  },
 });

dist/stepper/index.js

@@ -4,191 +4,181 @@ const LONG_PRESS_START_TIME = 600;
 const LONG_PRESS_INTERVAL = 200;
 // add num and avoid float number
 function add(num1, num2) {
-  const cardinal = Math.pow(10, 10);
+    const cardinal = Math.pow(10, 10);
-  return Math.round((num1 + num2) * cardinal) / cardinal;
+    return Math.round((num1 + num2) * cardinal) / cardinal;
 }
 function equal(value1, value2) {
-  return String(value1) === String(value2);
+    return String(value1) === String(value2);
 }
 VantComponent({
-  field: true,
+    field: true,
-  classes: ['input-class', 'plus-class', 'minus-class'],
+    classes: ['input-class', 'plus-class', 'minus-class'],
-  props: {
+    props: {
-    value: {
+        value: {
-      type: null,
+            type: null,
-      observer: 'observeValue',
+            observer: 'observeValue',
+        },
+        integer: {
+            type: Boolean,
+            observer: 'check',
+        },
+        disabled: Boolean,
+        inputWidth: String,
+        buttonSize: String,
+        asyncChange: Boolean,
+        disableInput: Boolean,
+        decimalLength: {
+            type: Number,
+            value: null,
+            observer: 'check',
+        },
+        min: {
+            type: null,
+            value: 1,
+            observer: 'check',
+        },
+        max: {
+            type: null,
+            value: Number.MAX_SAFE_INTEGER,
+            observer: 'check',
+        },
+        step: {
+            type: null,
+            value: 1,
+        },
+        showPlus: {
+            type: Boolean,
+            value: true,
+        },
+        showMinus: {
+            type: Boolean,
+            value: true,
+        },
+        disablePlus: Boolean,
+        disableMinus: Boolean,
+        longPress: {
+            type: Boolean,
+            value: true,
+        },
+        theme: String,
     },
-    integer: {
+    data: {
-      type: Boolean,
+        currentValue: '',
-      observer: 'check',
     },
-    disabled: Boolean,
+    created() {
-    inputWidth: String,
+        this.setData({
-    buttonSize: String,
+            currentValue: this.format(this.data.value),
-    asyncChange: Boolean,
+        });
-    disableInput: Boolean,
-    decimalLength: {
-      type: Number,
-      value: null,
-      observer: 'check',
     },
-    min: {
+    methods: {
-      type: null,
+        observeValue() {
-      value: 1,
+            const { value, currentValue } = this.data;
-      observer: 'check',
+            if (!equal(value, currentValue)) {
+                this.setData({ currentValue: this.format(value) });
+            }
+        },
+        check() {
+            const val = this.format(this.data.currentValue);
+            if (!equal(val, this.data.currentValue)) {
+                this.setData({ currentValue: val });
+            }
+        },
+        isDisabled(type) {
+            const { disabled, disablePlus, disableMinus, currentValue, max, min, } = this.data;
+            if (type === 'plus') {
+                return disabled || disablePlus || currentValue >= max;
+            }
+            return disabled || disableMinus || currentValue <= min;
+        },
+        onFocus(event) {
+            this.$emit('focus', event.detail);
+        },
+        onBlur(event) {
+            const value = this.format(event.detail.value);
+            this.emitChange(value);
+            this.$emit('blur', Object.assign(Object.assign({}, event.detail), { value }));
+        },
+        // filter illegal characters
+        filter(value) {
+            value = String(value).replace(/[^0-9.-]/g, '');
+            if (this.data.integer && value.indexOf('.') !== -1) {
+                value = value.split('.')[0];
+            }
+            return value;
+        },
+        // limit value range
+        format(value) {
+            value = this.filter(value);
+            // format range
+            value = value === '' ? 0 : +value;
+            value = Math.max(Math.min(this.data.max, value), this.data.min);
+            // format decimal
+            if (isDef(this.data.decimalLength)) {
+                value = value.toFixed(this.data.decimalLength);
+            }
+            return value;
+        },
+        onInput(event) {
+            const { value = '' } = event.detail || {};
+            // allow input to be empty
+            if (value === '') {
+                return;
+            }
+            let formatted = this.filter(value);
+            // limit max decimal length
+            if (isDef(this.data.decimalLength) && formatted.indexOf('.') !== -1) {
+                const pair = formatted.split('.');
+                formatted = `${pair[0]}.${pair[1].slice(0, this.data.decimalLength)}`;
+            }
+            this.emitChange(formatted);
+        },
+        emitChange(value) {
+            if (!this.data.asyncChange) {
+                this.setData({ currentValue: value });
+            }
+            this.$emit('change', value);
+        },
+        onChange() {
+            const { type } = this;
+            if (this.isDisabled(type)) {
+                this.$emit('overlimit', type);
+                return;
+            }
+            const diff = type === 'minus' ? -this.data.step : +this.data.step;
+            const value = this.format(add(+this.data.currentValue, diff));
+            this.emitChange(value);
+            this.$emit(type);
+        },
+        longPressStep() {
+            this.longPressTimer = setTimeout(() => {
+                this.onChange();
+                this.longPressStep();
+            }, LONG_PRESS_INTERVAL);
+        },
+        onTap(event) {
+            const { type } = event.currentTarget.dataset;
+            this.type = type;
+            this.onChange();
+        },
+        onTouchStart(event) {
+            if (!this.data.longPress) {
+                return;
+            }
+            clearTimeout(this.longPressTimer);
+            const { type } = event.currentTarget.dataset;
+            this.type = type;
+            this.isLongPress = false;
+            this.longPressTimer = setTimeout(() => {
+                this.isLongPress = true;
+                this.onChange();
+                this.longPressStep();
+            }, LONG_PRESS_START_TIME);
+        },
+        onTouchEnd() {
+            if (!this.data.longPress) {
+                return;
+            }
+            clearTimeout(this.longPressTimer);
+        },
     },
-    max: {
-      type: null,
-      value: Number.MAX_SAFE_INTEGER,
-      observer: 'check',
-    },
-    step: {
-      type: null,
-      value: 1,
-    },
-    showPlus: {
-      type: Boolean,
-      value: true,
-    },
-    showMinus: {
-      type: Boolean,
-      value: true,
-    },
-    disablePlus: Boolean,
-    disableMinus: Boolean,
-    longPress: {
-      type: Boolean,
-      value: true,
-    },
-    theme: String,
-  },
-  data: {
-    currentValue: '',
-  },
-  created() {
-    this.setData({
-      currentValue: this.format(this.data.value),
-    });
-  },
-  methods: {
-    observeValue() {
-      const { value, currentValue } = this.data;
-      if (!equal(value, currentValue)) {
-        this.setData({ currentValue: this.format(value) });
-      }
-    },
-    check() {
-      const val = this.format(this.data.currentValue);
-      if (!equal(val, this.data.currentValue)) {
-        this.setData({ currentValue: val });
-      }
-    },
-    isDisabled(type) {
-      const {
-        disabled,
-        disablePlus,
-        disableMinus,
-        currentValue,
-        max,
-        min,
-      } = this.data;
-      if (type === 'plus') {
-        return disabled || disablePlus || currentValue >= max;
-      }
-      return disabled || disableMinus || currentValue <= min;
-    },
-    onFocus(event) {
-      this.$emit('focus', event.detail);
-    },
-    onBlur(event) {
-      const value = this.format(event.detail.value);
-      this.emitChange(value);
-      this.$emit(
-        'blur',
-        Object.assign(Object.assign({}, event.detail), { value })
-      );
-    },
-    // filter illegal characters
-    filter(value) {
-      value = String(value).replace(/[^0-9.-]/g, '');
-      if (this.data.integer && value.indexOf('.') !== -1) {
-        value = value.split('.')[0];
-      }
-      return value;
-    },
-    // limit value range
-    format(value) {
-      value = this.filter(value);
-      // format range
-      value = value === '' ? 0 : +value;
-      value = Math.max(Math.min(this.data.max, value), this.data.min);
-      // format decimal
-      if (isDef(this.data.decimalLength)) {
-        value = value.toFixed(this.data.decimalLength);
-      }
-      return value;
-    },
-    onInput(event) {
-      const { value = '' } = event.detail || {};
-      // allow input to be empty
-      if (value === '') {
-        return;
-      }
-      let formatted = this.filter(value);
-      // limit max decimal length
-      if (isDef(this.data.decimalLength) && formatted.indexOf('.') !== -1) {
-        const pair = formatted.split('.');
-        formatted = `${pair[0]}.${pair[1].slice(0, this.data.decimalLength)}`;
-      }
-      this.emitChange(formatted);
-    },
-    emitChange(value) {
-      if (!this.data.asyncChange) {
-        this.setData({ currentValue: value });
-      }
-      this.$emit('change', value);
-    },
-    onChange() {
-      const { type } = this;
-      if (this.isDisabled(type)) {
-        this.$emit('overlimit', type);
-        return;
-      }
-      const diff = type === 'minus' ? -this.data.step : +this.data.step;
-      const value = this.format(add(+this.data.currentValue, diff));
-      this.emitChange(value);
-      this.$emit(type);
-    },
-    longPressStep() {
-      this.longPressTimer = setTimeout(() => {
-        this.onChange();
-        this.longPressStep();
-      }, LONG_PRESS_INTERVAL);
-    },
-    onTap(event) {
-      const { type } = event.currentTarget.dataset;
-      this.type = type;
-      this.onChange();
-    },
-    onTouchStart(event) {
-      if (!this.data.longPress) {
-        return;
-      }
-      clearTimeout(this.longPressTimer);
-      const { type } = event.currentTarget.dataset;
-      this.type = type;
-      this.isLongPress = false;
-      this.longPressTimer = setTimeout(() => {
-        this.isLongPress = true;
-        this.onChange();
-        this.longPressStep();
-      }, LONG_PRESS_START_TIME);
-    },
-    onTouchEnd() {
-      if (!this.data.longPress) {
-        return;
-      }
-      clearTimeout(this.longPressTimer);
-    },
-  },
 });

dist/steps/index.js

@@ -1,33 +1,33 @@
 import { VantComponent } from '../common/component';
 import { GREEN, GRAY_DARK } from '../common/color';
 VantComponent({
-  classes: ['desc-class'],
+    classes: ['desc-class'],
-  props: {
+    props: {
-    icon: String,
+        icon: String,
-    steps: Array,
+        steps: Array,
-    active: Number,
+        active: Number,
-    direction: {
+        direction: {
-      type: String,
+            type: String,
-      value: 'horizontal',
+            value: 'horizontal',
+        },
+        activeColor: {
+            type: String,
+            value: GREEN,
+        },
+        inactiveColor: {
+            type: String,
+            value: GRAY_DARK,
+        },
+        activeIcon: {
+            type: String,
+            value: 'checked',
+        },
+        inactiveIcon: String,
     },
-    activeColor: {
+    methods: {
-      type: String,
+        onClick(event) {
-      value: GREEN,
+            const { index } = event.currentTarget.dataset;
+            this.$emit('click-step', index);
+        },
     },
-    inactiveColor: {
-      type: String,
-      value: GRAY_DARK,
-    },
-    activeIcon: {
-      type: String,
-      value: 'checked',
-    },
-    inactiveIcon: String,
-  },
-  methods: {
-    onClick(event) {
-      const { index } = event.currentTarget.dataset;
-      this.$emit('click-step', index);
-    },
-  },
 });

dist/sticky/index.js

@@ -4,114 +4,115 @@ import { isDef } from '../common/validator';
 import { pageScrollMixin } from '../mixins/page-scroll';
 const ROOT_ELEMENT = '.van-sticky';
 VantComponent({
-  props: {
+    props: {
-    zIndex: {
+        zIndex: {
-      type: Number,
+            type: Number,
-      value: 99,
+            value: 99,
+        },
+        offsetTop: {
+            type: Number,
+            value: 0,
+            observer: 'onScroll',
+        },
+        disabled: {
+            type: Boolean,
+            observer: 'onScroll',
+        },
+        container: {
+            type: null,
+            observer: 'onScroll',
+        },
+        scrollTop: {
+            type: null,
+            observer(val) {
+                this.onScroll({ scrollTop: val });
+            },
+        },
     },
-    offsetTop: {
+    mixins: [
-      type: Number,
+        pageScrollMixin(function (event) {
-      value: 0,
+            if (this.data.scrollTop != null) {
-      observer: 'onScroll',
+                return;
+            }
+            this.onScroll(event);
+        }),
+    ],
+    data: {
+        height: 0,
+        fixed: false,
+        transform: 0,
     },
-    disabled: {
+    mounted() {
-      type: Boolean,
+        this.onScroll();
-      observer: 'onScroll',
     },
-    container: {
+    methods: {
-      type: null,
+        onScroll({ scrollTop } = {}) {
-      observer: 'onScroll',
+            const { container, offsetTop, disabled } = this.data;
-    },
+            if (disabled) {
-    scrollTop: {
+                this.setDataAfterDiff({
-      type: null,
+                    fixed: false,
-      observer(val) {
+                    transform: 0,
-        this.onScroll({ scrollTop: val });
+                });
-      },
+                return;
-    },
+            }
-  },
+            this.scrollTop = scrollTop || this.scrollTop;
-  mixins: [
+            if (typeof container === 'function') {
-    pageScrollMixin(function (event) {
+                Promise.all([
-      if (this.data.scrollTop != null) {
+                    getRect(this, ROOT_ELEMENT),
-        return;
+                    this.getContainerRect(),
-      }
+                ]).then(([root, container]) => {
-      this.onScroll(event);
+                    if (offsetTop + root.height > container.height + container.top) {
-    }),
+                        this.setDataAfterDiff({
-  ],
+                            fixed: false,
-  data: {
+                            transform: container.height - root.height,
-    height: 0,
+                        });
-    fixed: false,
+                    }
-    transform: 0,
+                    else if (offsetTop >= root.top) {
-  },
+                        this.setDataAfterDiff({
-  mounted() {
+                            fixed: true,
-    this.onScroll();
+                            height: root.height,
-  },
+                            transform: 0,
-  methods: {
+                        });
-    onScroll({ scrollTop } = {}) {
+                    }
-      const { container, offsetTop, disabled } = this.data;
+                    else {
-      if (disabled) {
+                        this.setDataAfterDiff({ fixed: false, transform: 0 });
-        this.setDataAfterDiff({
+                    }
-          fixed: false,
+                });
-          transform: 0,
+                return;
-        });
+            }
-        return;
+            getRect(this, ROOT_ELEMENT).then((root) => {
-      }
+                if (!isDef(root)) {
-      this.scrollTop = scrollTop || this.scrollTop;
+                    return;
-      if (typeof container === 'function') {
+                }
-        Promise.all([
+                if (offsetTop >= root.top) {
-          getRect(this, ROOT_ELEMENT),
+                    this.setDataAfterDiff({ fixed: true, height: root.height });
-          this.getContainerRect(),
+                    this.transform = 0;
-        ]).then(([root, container]) => {
+                }
-          if (offsetTop + root.height > container.height + container.top) {
+                else {
-            this.setDataAfterDiff({
+                    this.setDataAfterDiff({ fixed: false });
-              fixed: false,
+                }
-              transform: container.height - root.height,
             });
-          } else if (offsetTop >= root.top) {
+        },
-            this.setDataAfterDiff({
+        setDataAfterDiff(data) {
-              fixed: true,
+            wx.nextTick(() => {
-              height: root.height,
+                const diff = Object.keys(data).reduce((prev, key) => {
-              transform: 0,
+                    if (data[key] !== this.data[key]) {
+                        prev[key] = data[key];
+                    }
+                    return prev;
+                }, {});
+                if (Object.keys(diff).length > 0) {
+                    this.setData(diff);
+                }
+                this.$emit('scroll', {
+                    scrollTop: this.scrollTop,
+                    isFixed: data.fixed || this.data.fixed,
+                });
             });
-          } else {
+        },
-            this.setDataAfterDiff({ fixed: false, transform: 0 });
+        getContainerRect() {
-          }
+            const nodesRef = this.data.container();
-        });
+            return new Promise((resolve) => nodesRef.boundingClientRect(resolve).exec());
-        return;
+        },
-      }
-      getRect(this, ROOT_ELEMENT).then((root) => {
-        if (!isDef(root)) {
-          return;
-        }
-        if (offsetTop >= root.top) {
-          this.setDataAfterDiff({ fixed: true, height: root.height });
-          this.transform = 0;
-        } else {
-          this.setDataAfterDiff({ fixed: false });
-        }
-      });
     },
-    setDataAfterDiff(data) {
-      wx.nextTick(() => {
-        const diff = Object.keys(data).reduce((prev, key) => {
-          if (data[key] !== this.data[key]) {
-            prev[key] = data[key];
-          }
-          return prev;
-        }, {});
-        if (Object.keys(diff).length > 0) {
-          this.setData(diff);
-        }
-        this.$emit('scroll', {
-          scrollTop: this.scrollTop,
-          isFixed: data.fixed || this.data.fixed,
-        });
-      });
-    },
-    getContainerRect() {
-      const nodesRef = this.data.container();
-      return new Promise((resolve) =>
-        nodesRef.boundingClientRect(resolve).exec()
-      );
-    },
-  },
 });

dist/submit-bar/index.js

@@ -1,57 +1,56 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  classes: ['bar-class', 'price-class', 'button-class'],
+    classes: ['bar-class', 'price-class', 'button-class'],
-  props: {
+    props: {
-    tip: {
+        tip: {
-      type: null,
+            type: null,
-      observer: 'updateTip',
+            observer: 'updateTip',
+        },
+        tipIcon: String,
+        type: Number,
+        price: {
+            type: null,
+            observer: 'updatePrice',
+        },
+        label: String,
+        loading: Boolean,
+        disabled: Boolean,
+        buttonText: String,
+        currency: {
+            type: String,
+            value: '¥',
+        },
+        buttonType: {
+            type: String,
+            value: 'danger',
+        },
+        decimalLength: {
+            type: Number,
+            value: 2,
+            observer: 'updatePrice',
+        },
+        suffixLabel: String,
+        safeAreaInsetBottom: {
+            type: Boolean,
+            value: true,
+        },
     },
-    tipIcon: String,
+    methods: {
-    type: Number,
+        updatePrice() {
-    price: {
+            const { price, decimalLength } = this.data;
-      type: null,
+            const priceStrArr = typeof price === 'number' &&
-      observer: 'updatePrice',
+                (price / 100).toFixed(decimalLength).split('.');
+            this.setData({
+                hasPrice: typeof price === 'number',
+                integerStr: priceStrArr && priceStrArr[0],
+                decimalStr: decimalLength && priceStrArr ? `.${priceStrArr[1]}` : '',
+            });
+        },
+        updateTip() {
+            this.setData({ hasTip: typeof this.data.tip === 'string' });
+        },
+        onSubmit(event) {
+            this.$emit('submit', event.detail);
+        },
     },
-    label: String,
-    loading: Boolean,
-    disabled: Boolean,
-    buttonText: String,
-    currency: {
-      type: String,
-      value: '¥',
-    },
-    buttonType: {
-      type: String,
-      value: 'danger',
-    },
-    decimalLength: {
-      type: Number,
-      value: 2,
-      observer: 'updatePrice',
-    },
-    suffixLabel: String,
-    safeAreaInsetBottom: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  methods: {
-    updatePrice() {
-      const { price, decimalLength } = this.data;
-      const priceStrArr =
-        typeof price === 'number' &&
-        (price / 100).toFixed(decimalLength).split('.');
-      this.setData({
-        hasPrice: typeof price === 'number',
-        integerStr: priceStrArr && priceStrArr[0],
-        decimalStr: decimalLength && priceStrArr ? `.${priceStrArr[1]}` : '',
-      });
-    },
-    updateTip() {
-      this.setData({ hasTip: typeof this.data.tip === 'string' });
-    },
-    onSubmit(event) {
-      this.$emit('submit', event.detail);
-    },
-  },
 });

dist/swipe-cell/index.js

@@ -4,129 +4,130 @@ import { range } from '../common/utils';
 const THRESHOLD = 0.3;
 let ARRAY = [];
 VantComponent({
-  props: {
+    props: {
-    disabled: Boolean,
+        disabled: Boolean,
-    leftWidth: {
+        leftWidth: {
-      type: Number,
+            type: Number,
-      value: 0,
+            value: 0,
-      observer(leftWidth = 0) {
+            observer(leftWidth = 0) {
-        if (this.offset > 0) {
+                if (this.offset > 0) {
-          this.swipeMove(leftWidth);
+                    this.swipeMove(leftWidth);
-        }
+                }
-      },
+            },
+        },
+        rightWidth: {
+            type: Number,
+            value: 0,
+            observer(rightWidth = 0) {
+                if (this.offset < 0) {
+                    this.swipeMove(-rightWidth);
+                }
+            },
+        },
+        asyncClose: Boolean,
+        name: {
+            type: null,
+            value: '',
+        },
     },
-    rightWidth: {
+    mixins: [touch],
-      type: Number,
+    data: {
-      value: 0,
+        catchMove: false,
-      observer(rightWidth = 0) {
+        wrapperStyle: '',
-        if (this.offset < 0) {
-          this.swipeMove(-rightWidth);
-        }
-      },
     },
-    asyncClose: Boolean,
+    created() {
-    name: {
+        this.offset = 0;
-      type: null,
+        ARRAY.push(this);
-      value: '',
     },
-  },
+    destroyed() {
-  mixins: [touch],
+        ARRAY = ARRAY.filter((item) => item !== this);
-  data: {
-    catchMove: false,
-    wrapperStyle: '',
-  },
-  created() {
-    this.offset = 0;
-    ARRAY.push(this);
-  },
-  destroyed() {
-    ARRAY = ARRAY.filter((item) => item !== this);
-  },
-  methods: {
-    open(position) {
-      const { leftWidth, rightWidth } = this.data;
-      const offset = position === 'left' ? leftWidth : -rightWidth;
-      this.swipeMove(offset);
-      this.$emit('open', {
-        position,
-        name: this.data.name,
-      });
     },
-    close() {
+    methods: {
-      this.swipeMove(0);
+        open(position) {
-    },
+            const { leftWidth, rightWidth } = this.data;
-    swipeMove(offset = 0) {
+            const offset = position === 'left' ? leftWidth : -rightWidth;
-      this.offset = range(offset, -this.data.rightWidth, this.data.leftWidth);
+            this.swipeMove(offset);
-      const transform = `translate3d(${this.offset}px, 0, 0)`;
+            this.$emit('open', {
-      const transition = this.dragging
+                position,
-        ? 'none'
+                name: this.data.name,
-        : 'transform .6s cubic-bezier(0.18, 0.89, 0.32, 1)';
+            });
-      this.setData({
+        },
-        wrapperStyle: `
+        close() {
+            this.swipeMove(0);
+        },
+        swipeMove(offset = 0) {
+            this.offset = range(offset, -this.data.rightWidth, this.data.leftWidth);
+            const transform = `translate3d(${this.offset}px, 0, 0)`;
+            const transition = this.dragging
+                ? 'none'
+                : 'transform .6s cubic-bezier(0.18, 0.89, 0.32, 1)';
+            this.setData({
+                wrapperStyle: `
         -webkit-transform: ${transform};
         -webkit-transition: ${transition};
         transform: ${transform};
         transition: ${transition};
       `,
-      });
+            });
+        },
+        swipeLeaveTransition() {
+            const { leftWidth, rightWidth } = this.data;
+            const { offset } = this;
+            if (rightWidth > 0 && -offset > rightWidth * THRESHOLD) {
+                this.open('right');
+            }
+            else if (leftWidth > 0 && offset > leftWidth * THRESHOLD) {
+                this.open('left');
+            }
+            else {
+                this.swipeMove(0);
+            }
+            this.setData({ catchMove: false });
+        },
+        startDrag(event) {
+            if (this.data.disabled) {
+                return;
+            }
+            this.startOffset = this.offset;
+            this.touchStart(event);
+        },
+        noop() { },
+        onDrag(event) {
+            if (this.data.disabled) {
+                return;
+            }
+            this.touchMove(event);
+            if (this.direction !== 'horizontal') {
+                return;
+            }
+            this.dragging = true;
+            ARRAY.filter((item) => item !== this && item.offset !== 0).forEach((item) => item.close());
+            this.setData({ catchMove: true });
+            this.swipeMove(this.startOffset + this.deltaX);
+        },
+        endDrag() {
+            if (this.data.disabled) {
+                return;
+            }
+            this.dragging = false;
+            this.swipeLeaveTransition();
+        },
+        onClick(event) {
+            const { key: position = 'outside' } = event.currentTarget.dataset;
+            this.$emit('click', position);
+            if (!this.offset) {
+                return;
+            }
+            if (this.data.asyncClose) {
+                this.$emit('close', {
+                    position,
+                    instance: this,
+                    name: this.data.name,
+                });
+            }
+            else {
+                this.swipeMove(0);
+            }
+        },
     },
-    swipeLeaveTransition() {
-      const { leftWidth, rightWidth } = this.data;
-      const { offset } = this;
-      if (rightWidth > 0 && -offset > rightWidth * THRESHOLD) {
-        this.open('right');
-      } else if (leftWidth > 0 && offset > leftWidth * THRESHOLD) {
-        this.open('left');
-      } else {
-        this.swipeMove(0);
-      }
-      this.setData({ catchMove: false });
-    },
-    startDrag(event) {
-      if (this.data.disabled) {
-        return;
-      }
-      this.startOffset = this.offset;
-      this.touchStart(event);
-    },
-    noop() {},
-    onDrag(event) {
-      if (this.data.disabled) {
-        return;
-      }
-      this.touchMove(event);
-      if (this.direction !== 'horizontal') {
-        return;
-      }
-      this.dragging = true;
-      ARRAY.filter(
-        (item) => item !== this && item.offset !== 0
-      ).forEach((item) => item.close());
-      this.setData({ catchMove: true });
-      this.swipeMove(this.startOffset + this.deltaX);
-    },
-    endDrag() {
-      if (this.data.disabled) {
-        return;
-      }
-      this.dragging = false;
-      this.swipeLeaveTransition();
-    },
-    onClick(event) {
-      const { key: position = 'outside' } = event.currentTarget.dataset;
-      this.$emit('click', position);
-      if (!this.offset) {
-        return;
-      }
-      if (this.data.asyncClose) {
-        this.$emit('close', {
-          position,
-          instance: this,
-          name: this.data.name,
-        });
-      } else {
-        this.swipeMove(0);
-      }
-    },
-  },
 });

dist/switch/index.js

@@ -1,36 +1,36 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  field: true,
+    field: true,
-  classes: ['node-class'],
+    classes: ['node-class'],
-  props: {
+    props: {
-    checked: null,
+        checked: null,
-    loading: Boolean,
+        loading: Boolean,
-    disabled: Boolean,
+        disabled: Boolean,
-    activeColor: String,
+        activeColor: String,
-    inactiveColor: String,
+        inactiveColor: String,
-    size: {
+        size: {
-      type: String,
+            type: String,
-      value: '30',
+            value: '30',
+        },
+        activeValue: {
+            type: null,
+            value: true,
+        },
+        inactiveValue: {
+            type: null,
+            value: false,
+        },
     },
-    activeValue: {
+    methods: {
-      type: null,
+        onClick() {
-      value: true,
+            const { activeValue, inactiveValue, disabled, loading } = this.data;
+            if (disabled || loading) {
+                return;
+            }
+            const checked = this.data.checked === activeValue;
+            const value = checked ? inactiveValue : activeValue;
+            this.$emit('input', value);
+            this.$emit('change', value);
+        },
     },
-    inactiveValue: {
-      type: null,
-      value: false,
-    },
-  },
-  methods: {
-    onClick() {
-      const { activeValue, inactiveValue, disabled, loading } = this.data;
-      if (disabled || loading) {
-        return;
-      }
-      const checked = this.data.checked === activeValue;
-      const value = checked ? inactiveValue : activeValue;
-      this.$emit('input', value);
-      this.$emit('change', value);
-    },
-  },
 });

dist/tab/index.js

@@ -1,56 +1,56 @@
 import { useParent } from '../common/relation';
 import { VantComponent } from '../common/component';
 VantComponent({
-  relation: useParent('tabs'),
+    relation: useParent('tabs'),
-  props: {
+    props: {
-    dot: {
+        dot: {
-      type: Boolean,
+            type: Boolean,
-      observer: 'update',
+            observer: 'update',
+        },
+        info: {
+            type: null,
+            observer: 'update',
+        },
+        title: {
+            type: String,
+            observer: 'update',
+        },
+        disabled: {
+            type: Boolean,
+            observer: 'update',
+        },
+        titleStyle: {
+            type: String,
+            observer: 'update',
+        },
+        name: {
+            type: null,
+            value: '',
+        },
     },
-    info: {
+    data: {
-      type: null,
+        active: false,
-      observer: 'update',
     },
-    title: {
+    methods: {
-      type: String,
+        getComputedName() {
-      observer: 'update',
+            if (this.data.name !== '') {
+                return this.data.name;
+            }
+            return this.index;
+        },
+        updateRender(active, parent) {
+            const { data: parentData } = parent;
+            this.inited = this.inited || active;
+            this.setData({
+                active,
+                shouldRender: this.inited || !parentData.lazyRender,
+                shouldShow: active || parentData.animated,
+            });
+        },
+        update() {
+            if (this.parent) {
+                this.parent.updateTabs();
+            }
+        },
     },
-    disabled: {
-      type: Boolean,
-      observer: 'update',
-    },
-    titleStyle: {
-      type: String,
-      observer: 'update',
-    },
-    name: {
-      type: null,
-      value: '',
-    },
-  },
-  data: {
-    active: false,
-  },
-  methods: {
-    getComputedName() {
-      if (this.data.name !== '') {
-        return this.data.name;
-      }
-      return this.index;
-    },
-    updateRender(active, parent) {
-      const { data: parentData } = parent;
-      this.inited = this.inited || active;
-      this.setData({
-        active,
-        shouldRender: this.inited || !parentData.lazyRender,
-        shouldShow: active || parentData.animated,
-      });
-    },
-    update() {
-      if (this.parent) {
-        this.parent.updateTabs();
-      }
-    },
-  },
 });

dist/tabbar-item/index.js

@@ -1,56 +1,56 @@
 import { VantComponent } from '../common/component';
 import { useParent } from '../common/relation';
 VantComponent({
-  props: {
+    props: {
-    info: null,
+        info: null,
-    name: null,
+        name: null,
-    icon: String,
+        icon: String,
-    dot: Boolean,
+        dot: Boolean,
-    iconPrefix: {
+        iconPrefix: {
-      type: String,
+            type: String,
-      value: 'van-icon',
+            value: 'van-icon',
+        },
     },
-  },
+    relation: useParent('tabbar'),
-  relation: useParent('tabbar'),
+    data: {
-  data: {
+        active: false,
-    active: false,
+        activeColor: '',
-    activeColor: '',
+        inactiveColor: '',
-    inactiveColor: '',
-  },
-  methods: {
-    onClick() {
-      const { parent } = this;
-      if (parent) {
-        const index = parent.children.indexOf(this);
-        const active = this.data.name || index;
-        if (active !== this.data.active) {
-          parent.$emit('change', active);
-        }
-      }
-      this.$emit('click');
     },
-    updateFromParent() {
+    methods: {
-      const { parent } = this;
+        onClick() {
-      if (!parent) {
+            const { parent } = this;
-        return;
+            if (parent) {
-      }
+                const index = parent.children.indexOf(this);
-      const index = parent.children.indexOf(this);
+                const active = this.data.name || index;
-      const parentData = parent.data;
+                if (active !== this.data.active) {
-      const { data } = this;
+                    parent.$emit('change', active);
-      const active = (data.name || index) === parentData.active;
+                }
-      const patch = {};
+            }
-      if (active !== data.active) {
+            this.$emit('click');
-        patch.active = active;
+        },
-      }
+        updateFromParent() {
-      if (parentData.activeColor !== data.activeColor) {
+            const { parent } = this;
-        patch.activeColor = parentData.activeColor;
+            if (!parent) {
-      }
+                return;
-      if (parentData.inactiveColor !== data.inactiveColor) {
+            }
-        patch.inactiveColor = parentData.inactiveColor;
+            const index = parent.children.indexOf(this);
-      }
+            const parentData = parent.data;
-      if (Object.keys(patch).length > 0) {
+            const { data } = this;
-        this.setData(patch);
+            const active = (data.name || index) === parentData.active;
-      }
+            const patch = {};
+            if (active !== data.active) {
+                patch.active = active;
+            }
+            if (parentData.activeColor !== data.activeColor) {
+                patch.activeColor = parentData.activeColor;
+            }
+            if (parentData.inactiveColor !== data.inactiveColor) {
+                patch.inactiveColor = parentData.inactiveColor;
+            }
+            if (Object.keys(patch).length > 0) {
+                this.setData(patch);
+            }
+        },
     },
-  },
 });

dist/tabbar/index.js

@@ -2,64 +2,64 @@ import { VantComponent } from '../common/component';
 import { useChildren } from '../common/relation';
 import { getRect } from '../common/utils';
 VantComponent({
-  relation: useChildren('tabbar-item', function () {
+    relation: useChildren('tabbar-item', function () {
-    this.updateChildren();
+        this.updateChildren();
-  }),
+    }),
-  props: {
+    props: {
-    active: {
+        active: {
-      type: null,
+            type: null,
-      observer: 'updateChildren',
+            observer: 'updateChildren',
+        },
+        activeColor: {
+            type: String,
+            observer: 'updateChildren',
+        },
+        inactiveColor: {
+            type: String,
+            observer: 'updateChildren',
+        },
+        fixed: {
+            type: Boolean,
+            value: true,
+            observer: 'setHeight',
+        },
+        placeholder: {
+            type: Boolean,
+            observer: 'setHeight',
+        },
+        border: {
+            type: Boolean,
+            value: true,
+        },
+        zIndex: {
+            type: Number,
+            value: 1,
+        },
+        safeAreaInsetBottom: {
+            type: Boolean,
+            value: true,
+        },
     },
-    activeColor: {
+    data: {
-      type: String,
+        height: 50,
-      observer: 'updateChildren',
     },
-    inactiveColor: {
+    methods: {
-      type: String,
+        updateChildren() {
-      observer: 'updateChildren',
+            const { children } = this;
+            if (!Array.isArray(children) || !children.length) {
+                return;
+            }
+            children.forEach((child) => child.updateFromParent());
+        },
+        setHeight() {
+            if (!this.data.fixed || !this.data.placeholder) {
+                return;
+            }
+            wx.nextTick(() => {
+                getRect(this, '.van-tabbar').then((res) => {
+                    this.setData({ height: res.height });
+                });
+            });
+        },
     },
-    fixed: {
-      type: Boolean,
-      value: true,
-      observer: 'setHeight',
-    },
-    placeholder: {
-      type: Boolean,
-      observer: 'setHeight',
-    },
-    border: {
-      type: Boolean,
-      value: true,
-    },
-    zIndex: {
-      type: Number,
-      value: 1,
-    },
-    safeAreaInsetBottom: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    height: 50,
-  },
-  methods: {
-    updateChildren() {
-      const { children } = this;
-      if (!Array.isArray(children) || !children.length) {
-        return;
-      }
-      children.forEach((child) => child.updateFromParent());
-    },
-    setHeight() {
-      if (!this.data.fixed || !this.data.placeholder) {
-        return;
-      }
-      wx.nextTick(() => {
-        getRect(this, '.van-tabbar').then((res) => {
-          this.setData({ height: res.height });
-        });
-      });
-    },
-  },
 });

dist/tabs/index.js

@@ -1,286 +1,271 @@
 import { VantComponent } from '../common/component';
 import { touch } from '../mixins/touch';
-import {
+import { getAllRect, getRect, groupSetData, nextTick, requestAnimationFrame, } from '../common/utils';
-  getAllRect,
-  getRect,
-  groupSetData,
-  nextTick,
-  requestAnimationFrame,
-} from '../common/utils';
 import { isDef } from '../common/validator';
 import { useChildren } from '../common/relation';
 VantComponent({
-  mixins: [touch],
+    mixins: [touch],
-  classes: ['nav-class', 'tab-class', 'tab-active-class', 'line-class'],
+    classes: ['nav-class', 'tab-class', 'tab-active-class', 'line-class'],
-  relation: useChildren('tab', function () {
+    relation: useChildren('tab', function () {
-    this.updateTabs();
+        this.updateTabs();
-  }),
+    }),
-  props: {
+    props: {
-    sticky: Boolean,
+        sticky: Boolean,
-    border: Boolean,
+        border: Boolean,
-    swipeable: Boolean,
+        swipeable: Boolean,
-    titleActiveColor: String,
+        titleActiveColor: String,
-    titleInactiveColor: String,
+        titleInactiveColor: String,
-    color: String,
+        color: String,
-    animated: {
+        animated: {
-      type: Boolean,
+            type: Boolean,
-      observer() {
+            observer() {
-        this.children.forEach((child, index) =>
+                this.children.forEach((child, index) => child.updateRender(index === this.data.currentIndex, this));
-          child.updateRender(index === this.data.currentIndex, this)
+            },
-        );
+        },
-      },
+        lineWidth: {
+            type: null,
+            value: 40,
+            observer: 'resize',
+        },
+        lineHeight: {
+            type: null,
+            value: -1,
+        },
+        active: {
+            type: null,
+            value: 0,
+            observer(name) {
+                if (!this.skipInit) {
+                    this.skipInit = true;
+                }
+                if (name !== this.getCurrentName()) {
+                    this.setCurrentIndexByName(name);
+                }
+            },
+        },
+        type: {
+            type: String,
+            value: 'line',
+        },
+        ellipsis: {
+            type: Boolean,
+            value: true,
+        },
+        duration: {
+            type: Number,
+            value: 0.3,
+        },
+        zIndex: {
+            type: Number,
+            value: 1,
+        },
+        swipeThreshold: {
+            type: Number,
+            value: 5,
+            observer(value) {
+                this.setData({
+                    scrollable: this.children.length > value || !this.data.ellipsis,
+                });
+            },
+        },
+        offsetTop: {
+            type: Number,
+            value: 0,
+        },
+        lazyRender: {
+            type: Boolean,
+            value: true,
+        },
     },
-    lineWidth: {
+    data: {
-      type: null,
+        tabs: [],
-      value: 40,
+        scrollLeft: 0,
-      observer: 'resize',
+        scrollable: false,
+        currentIndex: 0,
+        container: null,
+        skipTransition: true,
+        scrollWithAnimation: false,
+        lineOffsetLeft: 0,
     },
-    lineHeight: {
+    mounted() {
-      type: null,
+        requestAnimationFrame(() => {
-      value: -1,
+            this.setData({
-    },
+                container: () => this.createSelectorQuery().select('.van-tabs'),
-    active: {
+            });
-      type: null,
+            if (!this.skipInit) {
-      value: 0,
+                this.resize();
-      observer(name) {
+                this.scrollIntoView();
-        if (!this.skipInit) {
+            }
-          this.skipInit = true;
-        }
-        if (name !== this.getCurrentName()) {
-          this.setCurrentIndexByName(name);
-        }
-      },
-    },
-    type: {
-      type: String,
-      value: 'line',
-    },
-    ellipsis: {
-      type: Boolean,
-      value: true,
-    },
-    duration: {
-      type: Number,
-      value: 0.3,
-    },
-    zIndex: {
-      type: Number,
-      value: 1,
-    },
-    swipeThreshold: {
-      type: Number,
-      value: 5,
-      observer(value) {
-        this.setData({
-          scrollable: this.children.length > value || !this.data.ellipsis,
         });
-      },
     },
-    offsetTop: {
+    methods: {
-      type: Number,
+        updateTabs() {
-      value: 0,
+            const { children = [], data } = this;
+            this.setData({
+                tabs: children.map((child) => child.data),
+                scrollable: this.children.length > data.swipeThreshold || !data.ellipsis,
+            });
+            this.setCurrentIndexByName(data.active || this.getCurrentName());
+        },
+        trigger(eventName, child) {
+            const { currentIndex } = this.data;
+            const currentChild = child || this.children[currentIndex];
+            if (!isDef(currentChild)) {
+                return;
+            }
+            this.$emit(eventName, {
+                index: currentChild.index,
+                name: currentChild.getComputedName(),
+                title: currentChild.data.title,
+            });
+        },
+        onTap(event) {
+            const { index } = event.currentTarget.dataset;
+            const child = this.children[index];
+            if (child.data.disabled) {
+                this.trigger('disabled', child);
+            }
+            else {
+                this.setCurrentIndex(index);
+                nextTick(() => {
+                    this.trigger('click');
+                });
+            }
+        },
+        // correct the index of active tab
+        setCurrentIndexByName(name) {
+            const { children = [] } = this;
+            const matched = children.filter((child) => child.getComputedName() === name);
+            if (matched.length) {
+                this.setCurrentIndex(matched[0].index);
+            }
+        },
+        setCurrentIndex(currentIndex) {
+            const { data, children = [] } = this;
+            if (!isDef(currentIndex) ||
+                currentIndex >= children.length ||
+                currentIndex < 0) {
+                return;
+            }
+            groupSetData(this, () => {
+                children.forEach((item, index) => {
+                    const active = index === currentIndex;
+                    if (active !== item.data.active || !item.inited) {
+                        item.updateRender(active, this);
+                    }
+                });
+            });
+            if (currentIndex === data.currentIndex) {
+                return;
+            }
+            const shouldEmitChange = data.currentIndex !== null;
+            this.setData({ currentIndex });
+            requestAnimationFrame(() => {
+                this.resize();
+                this.scrollIntoView();
+            });
+            nextTick(() => {
+                this.trigger('input');
+                if (shouldEmitChange) {
+                    this.trigger('change');
+                }
+            });
+        },
+        getCurrentName() {
+            const activeTab = this.children[this.data.currentIndex];
+            if (activeTab) {
+                return activeTab.getComputedName();
+            }
+        },
+        resize() {
+            if (this.data.type !== 'line') {
+                return;
+            }
+            const { currentIndex, ellipsis, skipTransition } = this.data;
+            Promise.all([
+                getAllRect(this, '.van-tab'),
+                getRect(this, '.van-tabs__line'),
+            ]).then(([rects = [], lineRect]) => {
+                const rect = rects[currentIndex];
+                if (rect == null) {
+                    return;
+                }
+                let lineOffsetLeft = rects
+                    .slice(0, currentIndex)
+                    .reduce((prev, curr) => prev + curr.width, 0);
+                lineOffsetLeft +=
+                    (rect.width - lineRect.width) / 2 + (ellipsis ? 0 : 8);
+                this.setData({ lineOffsetLeft });
+                if (skipTransition) {
+                    nextTick(() => {
+                        this.setData({ skipTransition: false });
+                    });
+                }
+            });
+        },
+        // scroll active tab into view
+        scrollIntoView() {
+            const { currentIndex, scrollable, scrollWithAnimation } = this.data;
+            if (!scrollable) {
+                return;
+            }
+            Promise.all([
+                getAllRect(this, '.van-tab'),
+                getRect(this, '.van-tabs__nav'),
+            ]).then(([tabRects, navRect]) => {
+                const tabRect = tabRects[currentIndex];
+                const offsetLeft = tabRects
+                    .slice(0, currentIndex)
+                    .reduce((prev, curr) => prev + curr.width, 0);
+                this.setData({
+                    scrollLeft: offsetLeft - (navRect.width - tabRect.width) / 2,
+                });
+                if (!scrollWithAnimation) {
+                    nextTick(() => {
+                        this.setData({ scrollWithAnimation: true });
+                    });
+                }
+            });
+        },
+        onTouchScroll(event) {
+            this.$emit('scroll', event.detail);
+        },
+        onTouchStart(event) {
+            if (!this.data.swipeable)
+                return;
+            this.touchStart(event);
+        },
+        onTouchMove(event) {
+            if (!this.data.swipeable)
+                return;
+            this.touchMove(event);
+        },
+        // watch swipe touch end
+        onTouchEnd() {
+            if (!this.data.swipeable)
+                return;
+            const { direction, deltaX, offsetX } = this;
+            const minSwipeDistance = 50;
+            if (direction === 'horizontal' && offsetX >= minSwipeDistance) {
+                const index = this.getAvaiableTab(deltaX);
+                if (index !== -1) {
+                    this.setCurrentIndex(index);
+                }
+            }
+        },
+        getAvaiableTab(direction) {
+            const { tabs, currentIndex } = this.data;
+            const step = direction > 0 ? -1 : 1;
+            for (let i = step; currentIndex + i < tabs.length && currentIndex + i >= 0; i += step) {
+                const index = currentIndex + i;
+                if (index >= 0 &&
+                    index < tabs.length &&
+                    tabs[index] &&
+                    !tabs[index].disabled) {
+                    return index;
+                }
+            }
+            return -1;
+        },
     },
-    lazyRender: {
-      type: Boolean,
-      value: true,
-    },
-  },
-  data: {
-    tabs: [],
-    scrollLeft: 0,
-    scrollable: false,
-    currentIndex: 0,
-    container: null,
-    skipTransition: true,
-    scrollWithAnimation: false,
-    lineOffsetLeft: 0,
-  },
-  mounted() {
-    requestAnimationFrame(() => {
-      this.setData({
-        container: () => this.createSelectorQuery().select('.van-tabs'),
-      });
-      if (!this.skipInit) {
-        this.resize();
-        this.scrollIntoView();
-      }
-    });
-  },
-  methods: {
-    updateTabs() {
-      const { children = [], data } = this;
-      this.setData({
-        tabs: children.map((child) => child.data),
-        scrollable:
-          this.children.length > data.swipeThreshold || !data.ellipsis,
-      });
-      this.setCurrentIndexByName(data.active || this.getCurrentName());
-    },
-    trigger(eventName, child) {
-      const { currentIndex } = this.data;
-      const currentChild = child || this.children[currentIndex];
-      if (!isDef(currentChild)) {
-        return;
-      }
-      this.$emit(eventName, {
-        index: currentChild.index,
-        name: currentChild.getComputedName(),
-        title: currentChild.data.title,
-      });
-    },
-    onTap(event) {
-      const { index } = event.currentTarget.dataset;
-      const child = this.children[index];
-      if (child.data.disabled) {
-        this.trigger('disabled', child);
-      } else {
-        this.setCurrentIndex(index);
-        nextTick(() => {
-          this.trigger('click');
-        });
-      }
-    },
-    // correct the index of active tab
-    setCurrentIndexByName(name) {
-      const { children = [] } = this;
-      const matched = children.filter(
-        (child) => child.getComputedName() === name
-      );
-      if (matched.length) {
-        this.setCurrentIndex(matched[0].index);
-      }
-    },
-    setCurrentIndex(currentIndex) {
-      const { data, children = [] } = this;
-      if (
-        !isDef(currentIndex) ||
-        currentIndex >= children.length ||
-        currentIndex < 0
-      ) {
-        return;
-      }
-      groupSetData(this, () => {
-        children.forEach((item, index) => {
-          const active = index === currentIndex;
-          if (active !== item.data.active || !item.inited) {
-            item.updateRender(active, this);
-          }
-        });
-      });
-      if (currentIndex === data.currentIndex) {
-        return;
-      }
-      const shouldEmitChange = data.currentIndex !== null;
-      this.setData({ currentIndex });
-      requestAnimationFrame(() => {
-        this.resize();
-        this.scrollIntoView();
-      });
-      nextTick(() => {
-        this.trigger('input');
-        if (shouldEmitChange) {
-          this.trigger('change');
-        }
-      });
-    },
-    getCurrentName() {
-      const activeTab = this.children[this.data.currentIndex];
-      if (activeTab) {
-        return activeTab.getComputedName();
-      }
-    },
-    resize() {
-      if (this.data.type !== 'line') {
-        return;
-      }
-      const { currentIndex, ellipsis, skipTransition } = this.data;
-      Promise.all([
-        getAllRect(this, '.van-tab'),
-        getRect(this, '.van-tabs__line'),
-      ]).then(([rects = [], lineRect]) => {
-        const rect = rects[currentIndex];
-        if (rect == null) {
-          return;
-        }
-        let lineOffsetLeft = rects
-          .slice(0, currentIndex)
-          .reduce((prev, curr) => prev + curr.width, 0);
-        lineOffsetLeft +=
-          (rect.width - lineRect.width) / 2 + (ellipsis ? 0 : 8);
-        this.setData({ lineOffsetLeft });
-        if (skipTransition) {
-          nextTick(() => {
-            this.setData({ skipTransition: false });
-          });
-        }
-      });
-    },
-    // scroll active tab into view
-    scrollIntoView() {
-      const { currentIndex, scrollable, scrollWithAnimation } = this.data;
-      if (!scrollable) {
-        return;
-      }
-      Promise.all([
-        getAllRect(this, '.van-tab'),
-        getRect(this, '.van-tabs__nav'),
-      ]).then(([tabRects, navRect]) => {
-        const tabRect = tabRects[currentIndex];
-        const offsetLeft = tabRects
-          .slice(0, currentIndex)
-          .reduce((prev, curr) => prev + curr.width, 0);
-        this.setData({
-          scrollLeft: offsetLeft - (navRect.width - tabRect.width) / 2,
-        });
-        if (!scrollWithAnimation) {
-          nextTick(() => {
-            this.setData({ scrollWithAnimation: true });
-          });
-        }
-      });
-    },
-    onTouchScroll(event) {
-      this.$emit('scroll', event.detail);
-    },
-    onTouchStart(event) {
-      if (!this.data.swipeable) return;
-      this.touchStart(event);
-    },
-    onTouchMove(event) {
-      if (!this.data.swipeable) return;
-      this.touchMove(event);
-    },
-    // watch swipe touch end
-    onTouchEnd() {
-      if (!this.data.swipeable) return;
-      const { direction, deltaX, offsetX } = this;
-      const minSwipeDistance = 50;
-      if (direction === 'horizontal' && offsetX >= minSwipeDistance) {
-        const index = this.getAvaiableTab(deltaX);
-        if (index !== -1) {
-          this.setCurrentIndex(index);
-        }
-      }
-    },
-    getAvaiableTab(direction) {
-      const { tabs, currentIndex } = this.data;
-      const step = direction > 0 ? -1 : 1;
-      for (
-        let i = step;
-        currentIndex + i < tabs.length && currentIndex + i >= 0;
-        i += step
-      ) {
-        const index = currentIndex + i;
-        if (
-          index >= 0 &&
-          index < tabs.length &&
-          tabs[index] &&
-          !tabs[index].disabled
-        ) {
-          return index;
-        }
-      }
-      return -1;
-    },
-  },
 });

dist/tag/index.js

@@ -1,21 +1,21 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    size: String,
+        size: String,
-    mark: Boolean,
+        mark: Boolean,
-    color: String,
+        color: String,
-    plain: Boolean,
+        plain: Boolean,
-    round: Boolean,
+        round: Boolean,
-    textColor: String,
+        textColor: String,
-    type: {
+        type: {
-      type: String,
+            type: String,
-      value: 'default',
+            value: 'default',
+        },
+        closeable: Boolean,
     },
-    closeable: Boolean,
+    methods: {
-  },
+        onClose() {
-  methods: {
+            this.$emit('close');
-    onClose() {
+        },
-      this.$emit('close');
     },
-  },
 });

dist/toast/index.js

@@ -1,29 +1,29 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-  props: {
+    props: {
-    show: Boolean,
+        show: Boolean,
-    mask: Boolean,
+        mask: Boolean,
-    message: String,
+        message: String,
-    forbidClick: Boolean,
+        forbidClick: Boolean,
-    zIndex: {
+        zIndex: {
-      type: Number,
+            type: Number,
-      value: 1000,
+            value: 1000,
+        },
+        type: {
+            type: String,
+            value: 'text',
+        },
+        loadingType: {
+            type: String,
+            value: 'circular',
+        },
+        position: {
+            type: String,
+            value: 'middle',
+        },
     },
-    type: {
+    methods: {
-      type: String,
+        // for prevent touchmove
-      value: 'text',
+        noop() { },
     },
-    loadingType: {
-      type: String,
-      value: 'circular',
-    },
-    position: {
-      type: String,
-      value: 'middle',
-    },
-  },
-  methods: {
-    // for prevent touchmove
-    noop() {},
-  },
 });

dist/toast/toast.d.ts

@@ -1,36 +1,26 @@
 /// <reference types="miniprogram-api-typings" />
 declare type ToastMessage = string | number;
 interface ToastOptions {
-  show?: boolean;
+    show?: boolean;
-  type?: string;
+    type?: string;
-  mask?: boolean;
+    mask?: boolean;
-  zIndex?: number;
+    zIndex?: number;
-  context?:
+    context?: WechatMiniprogram.Component.TrivialInstance | WechatMiniprogram.Page.TrivialInstance;
-    | WechatMiniprogram.Component.TrivialInstance
+    position?: string;
-    | WechatMiniprogram.Page.TrivialInstance;
+    duration?: number;
-  position?: string;
+    selector?: string;
-  duration?: number;
+    forbidClick?: boolean;
-  selector?: string;
+    loadingType?: string;
-  forbidClick?: boolean;
+    message?: ToastMessage;
-  loadingType?: string;
+    onClose?: () => void;
-  message?: ToastMessage;
-  onClose?: () => void;
 }
-declare function Toast(
+declare function Toast(toastOptions: ToastOptions | ToastMessage): WechatMiniprogram.Component.TrivialInstance | undefined;
-  toastOptions: ToastOptions | ToastMessage
-): WechatMiniprogram.Component.TrivialInstance | undefined;
 declare namespace Toast {
-  var loading: (
+    var loading: (options: ToastMessage | ToastOptions) => WechatMiniprogram.Component.TrivialInstance | undefined;
-    options: ToastMessage | ToastOptions
+    var success: (options: ToastMessage | ToastOptions) => WechatMiniprogram.Component.TrivialInstance | undefined;
-  ) => WechatMiniprogram.Component.TrivialInstance | undefined;
+    var fail: (options: ToastMessage | ToastOptions) => WechatMiniprogram.Component.TrivialInstance | undefined;
-  var success: (
+    var clear: () => void;
-    options: ToastMessage | ToastOptions
+    var setDefaultOptions: (options: ToastOptions) => void;
-  ) => WechatMiniprogram.Component.TrivialInstance | undefined;
+    var resetDefaultOptions: () => void;
-  var fail: (
-    options: ToastMessage | ToastOptions
-  ) => WechatMiniprogram.Component.TrivialInstance | undefined;
-  var clear: () => void;
-  var setDefaultOptions: (options: ToastOptions) => void;
-  var resetDefaultOptions: () => void;
 }
 export default Toast;