build

dist/area/index.js

@@ -2,14 +2,8 @@ import { VantComponent } from '../common/component';
 VantComponent({
     props: {
         title: String,
+        value: String,
         loading: Boolean,
-        value: {
-            type: String,
-            observer(value) {
-                this.code = value;
-                this.setValues();
-            }
-        },
         itemHeight: {
             type: Number,
             value: 44
@@ -24,10 +18,7 @@ VantComponent({
         },
         areaList: {
             type: Object,
-            value: {},
+            value: {}
-            observer() {
-                this.setValues();
-            }
         }
     },
     data: {
@@ -40,6 +31,13 @@ VantComponent({
             return columns.slice(0, +columnsNum);
         }
     },
+    watch: {
+        value(value) {
+            this.code = value;
+            this.setValues();
+        },
+        areaList: 'setValues'
+    },
     methods: {
         onCancel() {
             this.$emit('cancel', {

dist/badge-group/index.js

@@ -1,28 +1,29 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-    relations: {
+    relation: {
-        '../badge/index': {
+        name: 'badge',
-            type: 'descendant',
+        type: 'descendant',
-            linked(target) {
+        linked(target) {
-                this.data.badges.push(target);
+            this.data.badges.push(target);
-                this.setActive();
+            this.setActive();
-            },
+        },
-            unlinked(target) {
+        unlinked(target) {
-                this.data.badges = this.data.badges.filter(item => item !== target);
+            this.data.badges = this.data.badges.filter(item => item !== target);
-                this.setActive();
+            this.setActive();
-            }
         }
     },
     props: {
         active: {
             type: Number,
-            value: 0,
+            value: 0
-            observer: 'setActive'
         }
     },
     data: {
         badges: []
     },
+    watch: {
+        active: 'setActive'
+    },
     beforeCreate() {
         this.currentActive = -1;
     },

dist/badge/index.js

@@ -1,9 +1,8 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-    relations: {
+    relation: {
-        '../badge-group/index': {
+        type: 'ancestor',
-            type: 'ancestor'
+        name: 'badge-group'
-        }
     },
     props: {
         info: Number,

dist/button/index.js

@@ -1,7 +1,8 @@
 import { VantComponent } from '../common/component';
 import { button } from '../mixins/button';
+import { openType } from '../mixins/open-type';
 VantComponent({
-    mixins: [button],
+    mixins: [button, openType],
     props: {
         plain: Boolean,
         block: Boolean,

dist/button/index.wxml

@@ -1,5 +1,6 @@
 <button
   class="custom-class van-button {{ classes }}"
+  id="{{ id }}"
   disabled="{{ disabled }}"
   hover-class="button-hover"
   open-type="{{ openType }}"
@@ -14,11 +15,11 @@
   send-message-img="{{ sendMessageImg }}"
   show-message-card="{{ showMessageCard }}"
   bind:tap="onClick"
-  bindcontact="bindcontact"
+  bindcontact="bindContact"
-  bindgetuserinfo="bindgetuserinfo"
+  bindgetuserinfo="bindGetUserInfo"
-  bindgetphonenumber="bindgetphonenumber"
+  bindgetphonenumber="bindGetPhoneNumber"
-  binderror="binderror"
+  binderror="bindError"
-  bindopensetting="bindopensetting"
+  bindopensetting="bindOpenSetting"
 >
   <van-loading
     wx:if="{{ loading }}"

dist/col/index.js

@@ -1,9 +1,8 @@
 import { VantComponent } from '../common/component';
 VantComponent({
-    relations: {
+    relation: {
-        '../row/index': {
+        name: 'row',
-            type: 'ancestor'
+        type: 'ancestor'
-        }
     },
     props: {
         span: Number,

dist/common/component.js

@@ -2,12 +2,14 @@ import { basic } from '../mixins/basic';
 import { observe } from '../mixins/observer/index';
 function mapKeys(source, target, map) {
     Object.keys(map).forEach(key => {
-        target[map[key]] = source[key];
+        if (source[key]) {
+            target[map[key]] = source[key];
+        }
     });
 }
-function VantComponent(sfc) {
+function VantComponent(vantOptions) {
     const options = {};
-    mapKeys(sfc, options, {
+    mapKeys(vantOptions, options, {
         data: 'data',
         props: 'properties',
         mixins: 'behaviors',
@@ -15,10 +17,16 @@ function VantComponent(sfc) {
         beforeCreate: 'created',
         created: 'attached',
         mounted: 'ready',
-        destroyed: 'detached',
         relations: 'relations',
+        destroyed: 'detached',
         classes: 'externalClasses'
     });
+    const { relation } = vantOptions;
+    if (relation) {
+        options.relations = Object.assign(options.relations || {}, {
+            [`../${relation.name}/index`]: relation
+        });
+    }
     // add default externalClasses
     options.externalClasses = options.externalClasses || [];
     options.externalClasses.push('custom-class');
@@ -26,7 +34,7 @@ function VantComponent(sfc) {
     options.behaviors = options.behaviors || [];
     options.behaviors.push(basic);
     // map field to form-field behavior
-    if (sfc.field) {
+    if (vantOptions.field) {
         options.behaviors.push('wx://form-field');
     }
     // add default options
@@ -34,7 +42,7 @@ function VantComponent(sfc) {
         multipleSlots: true,
         addGlobalClass: true
     };
-    observe(sfc, options);
+    observe(vantOptions, options);
     Component(options);
 }
 export { VantComponent };

dist/dialog/index.js

@@ -1,25 +1,15 @@
 import { VantComponent } from '../common/component';
+import { openType } from '../mixins/open-type';
 VantComponent({
+    mixins: [openType],
     props: {
+        show: Boolean,
         title: String,
         message: String,
         useSlot: Boolean,
         asyncClose: Boolean,
         showCancelButton: Boolean,
         confirmButtonOpenType: String,
-        show: {
-            type: Boolean,
-            observer(show) {
-                if (!show) {
-                    this.setData({
-                        loading: {
-                            confirm: false,
-                            cancel: false
-                        }
-                    });
-                }
-            }
-        },
         zIndex: {
             type: Number,
             value: 100
@@ -51,6 +41,18 @@ VantComponent({
             cancel: false
         }
     },
+    watch: {
+        show(show) {
+            if (!show) {
+                this.setData({
+                    loading: {
+                        confirm: false,
+                        cancel: false
+                    }
+                });
+            }
+        }
+    },
     methods: {
         onConfirm() {
             this.handleAction('confirm');
@@ -70,7 +72,9 @@ VantComponent({
             this.onClose(action);
         },
         close() {
-            this.setData({ show: false });
+            this.setData({
+                show: false
+            });
         },
         onClose(action) {
             if (!this.data.asyncClose) {

dist/dialog/index.wxml

@@ -37,6 +37,11 @@
         custom-class="van-dialog__confirm"
         open-type="{{ confirmButtonOpenType }}"
         bind:click="onConfirm"
+        bindcontact="bindContact"
+        bindgetuserinfo="bindGetUserInfo"
+        bindgetphonenumber="bindGetPhoneNumber"
+        binderror="bindError"
+        bindopensetting="bindOpenSetting"
       >
         {{ confirmButtonText }}
       </van-button>

dist/mixins/button.js

@@ -1,50 +1,27 @@
 export const button = Behavior({
-  properties: {
+    properties: {
-    loading: Boolean,
+        id: String,
-    openType: String,
+        appParameter: String,
-    appParameter: String,
+        sendMessageTitle: String,
-    sendMessageTitle: String,
+        sendMessagePath: String,
-    sendMessagePath: String,
+        sendMessageImg: String,
-    sendMessageImg: String,
+        showMessageCard: String,
-    showMessageCard: String,
+        hoverStopPropagation: Boolean,
-    hoverStopPropagation: Boolean,
+        hoverStartTime: {
-    hoverStartTime: {
+            type: Number,
-      type: Number,
+            value: 20
-      value: 20
+        },
-    },
+        hoverStayTime: {
-    hoverStayTime: {
+            type: Number,
-      type: Number,
+            value: 70
-      value: 70
+        },
-    },
+        lang: {
-    lang: {
+            type: String,
-      type: String,
+            value: 'en'
-      value: 'en'
+        },
-    },
+        sessionFrom: {
-    sessionFrom: {
+            type: String,
-      type: String,
+            value: ''
-      value: ''
+        }
     }
-  },
-
-  methods: {
-    bindgetuserinfo(event = {}) {
-      this.$emit('getuserinfo', event.detail);
-    },
-
-    bindcontact(event = {}) {
-      this.$emit('contact', event.detail);
-    },
-
-    bindgetphonenumber(event = {}) {
-      this.$emit('getphonenumber', event.detail);
-    },
-
-    bindopensetting(event = {}) {
-      this.$emit('opensetting', event.detail);
-    },
-
-    binderror(event = {}) {
-      this.$emit('error', event.detail);
-    }
-  }
 });

dist/mixins/observer/index.js

@@ -1,10 +1,25 @@
 import { behavior } from './behavior';
 import { observeProps } from './props';
-export function observe(sfc, options) {
+export function observe(vantOptions, options) {
-    if (sfc.computed) {
+    const { watch, computed } = vantOptions;
+    if (watch) {
+        const props = options.properties || {};
+        Object.keys(watch).forEach(key => {
+            if (key in props) {
+                let prop = props[key];
+                if (prop === null || !prop.type) {
+                    prop = { type: prop };
+                }
+                prop.observer = watch[key];
+                props[key] = prop;
+            }
+        });
+        options.properties = props;
+    }
+    if (computed) {
         options.behaviors.push(behavior);
         options.methods = options.methods || {};
-        options.methods.$options = () => sfc;
+        options.methods.$options = () => vantOptions;
         if (options.properties) {
             observeProps(options.properties);
         }

dist/mixins/open-type.js

@@ -0,0 +1,22 @@
+export const openType = Behavior({
+    properties: {
+        openType: String
+    },
+    methods: {
+        bindGetUserInfo(event) {
+            this.$emit('getuserinfo', event.detail);
+        },
+        bindContact(event) {
+            this.$emit('contact', event.detail);
+        },
+        bindGetPhoneNumber(event) {
+            this.$emit('getphonenumber', event.detail);
+        },
+        bindOpenSetting(event) {
+            this.$emit('opensetting', event.detail);
+        },
+        bindError(event) {
+            this.$emit('error', event.detail);
+        }
+    }
+});

dist/mixins/touch.js

@@ -1,22 +1,21 @@
 export const touch = Behavior({
-  methods: {
+    methods: {
-    touchStart(event) {
+        touchStart(event) {
-      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;
-      this.startX = event.touches[0].clientX;
+            this.startX = event.touches[0].clientX;
-      this.startY = event.touches[0].clientY;
+            this.startY = event.touches[0].clientY;
-    },
+        },
-
+        touchMove(event) {
-    touchMove(event) {
+            const touch = event.touches[0];
-      const touch = event.touches[0];
+            this.deltaX = touch.clientX - this.startX;
-      this.deltaX = touch.clientX - this.startX;
+            this.deltaY = touch.clientY - this.startY;
-      this.deltaY = touch.clientY - this.startY;
+            this.offsetX = Math.abs(this.deltaX);
-      this.offsetX = Math.abs(this.deltaX);
+            this.offsetY = Math.abs(this.deltaY);
-      this.offsetY = Math.abs(this.deltaY);
+            this.direction = this.offsetX > this.offsetY ? 'horizontal' : this.offsetX < this.offsetY ? 'vertical' : '';
-      this.direction = this.offsetX > this.offsetY ? 'horizontal' : this.offsetX < this.offsetY ? 'vertical' : '';
+        }
     }
-  }
 });

dist/mixins/transition.js

@@ -1,54 +1,52 @@
-export const transition = function(showDefaultValue) {
+export const transition = function (showDefaultValue) {
-  return Behavior({
+    return Behavior({
-    properties: {
+        properties: {
-      customStyle: String,
+            customStyle: String,
-      show: {
+            show: {
-        value: showDefaultValue,
+                type: Boolean,
-        type: Boolean,
+                value: showDefaultValue,
-        observer(value) {
+                observer: 'observeShow'
-          if (value) {
+            },
-            this.show();
+            duration: {
-          } else {
+                type: Number,
-            this.setData({
+                value: 300
-              type: 'leave'
+            }
-            });
+        },
-          }
+        data: {
-        }
+            type: '',
-      },
+            inited: false,
-      duration: {
-        type: Number,
-        value: 300
-      }
-    },
-
-    data: {
-      type: '',
-      inited: false,
-      display: false
-    },
-
-    attached() {
-      if (this.data.show) {
-        this.show();
-      }
-    },
-
-    methods: {
-      show() {
-        this.setData({
-          inited: true,
-          display: true,
-          type: 'enter'
-        });
-      },
-
-      onAnimationEnd() {
-        if (!this.data.show) {
-          this.setData({
             display: false
-          });
+        },
+        attached() {
+            if (this.data.show) {
+                this.show();
+            }
+        },
+        methods: {
+            observeShow(value) {
+                if (value) {
+                    this.show();
+                }
+                else {
+                    this.setData({
+                        type: 'leave'
+                    });
+                }
+            },
+            show() {
+                this.setData({
+                    inited: true,
+                    display: true,
+                    type: 'enter'
+                });
+            },
+            onAnimationEnd() {
+                if (!this.data.show) {
+                    this.setData({
+                        display: false
+                    });
+                }
+            }
         }
-      }
+    });
-    }
-  });
 };

dist/nav-bar/index.js

@@ -1,27 +1,23 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  classes: ['title-class'],
+    classes: ['title-class'],
-
+    props: {
-  props: {
+        title: String,
-    title: String,
+        leftText: String,
-    leftText: String,
+        rightText: String,
-    rightText: String,
+        leftArrow: Boolean,
-    leftArrow: Boolean,
+        fixed: Boolean,
-    fixed: Boolean,
+        zIndex: {
-    zIndex: {
+            type: Number,
-      type: Number,
+            value: 1
-      value: 1
+        }
-    }
-  },
-
-  methods: {
-    onClickLeft() {
-      this.$emit('click-left');
     },
-
+    methods: {
-    onClickRight() {
+        onClickLeft() {
-      this.$emit('click-right');
+            this.$emit('click-left');
+        },
+        onClickRight() {
+            this.$emit('click-right');
+        }
     }
-  }
 });

dist/notice-bar/index.js

@@ -1,159 +1,142 @@
 import { VantComponent } from '../common/component';
-
 const FONT_COLOR = '#f60';
 const BG_COLOR = '#fff7cc';
-
 VantComponent({
-  props: {
+    props: {
-    text: {
+        text: {
-      type: String,
+            type: String,
-      value: '',
+            value: ''
-      observer() {
+        },
-        this.setData({}, this.init);
+        mode: {
-      }
+            type: String,
-    },
+            value: ''
-    mode: {
+        },
-      type: String,
+        url: {
-      value: ''
+            type: String,
-    },
+            value: ''
-    url: {
+        },
-      type: String,
+        openType: {
-      value: ''
+            type: String,
-    },
+            value: 'navigate'
-    openType: {
+        },
-      type: String,
+        delay: {
-      value: 'navigate'
+            type: Number,
-    },
+            value: 0
-    delay: {
+        },
-      type: Number,
+        speed: {
-      value: 0
+            type: Number,
-    },
+            value: 50
-    speed: {
+        },
-      type: Number,
+        scrollable: {
-      value: 50
+            type: Boolean,
-    },
+            value: true
-    scrollable: {
+        },
-      type: Boolean,
+        leftIcon: {
-      value: true
+            type: String,
-    },
+            value: ''
-    leftIcon: {
+        },
-      type: String,
+        color: {
-      value: ''
+            type: String,
-    },
+            value: FONT_COLOR
-    color: {
+        },
-      type: String,
+        backgroundColor: {
-      value: FONT_COLOR
+            type: String,
-    },
+            value: BG_COLOR
-    backgroundColor: {
-      type: String,
-      value: BG_COLOR
-    }
-  },
-
-  data: {
-    show: true,
-    hasRightIcon: false,
-    width: undefined,
-    wrapWidth: undefined,
-    elapse: undefined,
-    animation: null,
-    resetAnimation: null,
-    timer: null
-  },
-
-  created() {
-    if (this.data.mode) {
-      this.setData({
-        hasRightIcon: true
-      });
-    }
-  },
-
-  destroyed() {
-    const { timer } = this.data;
-    timer && clearTimeout(timer);
-  },
-
-  methods: {
-    init() {
-      this.getRect('.van-notice-bar__content').then(rect => {
-        if (!rect || !rect.width) {
-          return;
         }
-        this.setData({
-          width: rect.width
-        });
-
-        this.getRect('.van-notice-bar__content-wrap').then(rect => {
-          if (!rect || !rect.width) {
-            return;
-          }
-
-          const wrapWidth = rect.width;
-          const {
-            width, speed, scrollable, delay
-          } = this.data;
-
-          if (scrollable && wrapWidth < width) {
-            const elapse = width / speed * 1000;
-            const animation = wx.createAnimation({
-              duration: elapse,
-              timeingFunction: 'linear',
-              delay
-            });
-            const resetAnimation = wx.createAnimation({
-              duration: 0,
-              timeingFunction: 'linear'
-            });
-
-            this.setData({
-              elapse,
-              wrapWidth,
-              animation,
-              resetAnimation
-            }, () => {
-              this.scroll();
-            });
-          }
-        });
-      });
     },
-
+    data: {
-    scroll() {
+        show: true,
-      const {
+        hasRightIcon: false,
-        animation, resetAnimation, wrapWidth, elapse, speed
+        width: undefined,
-      } = this.data;
+        wrapWidth: undefined,
-      resetAnimation.translateX(wrapWidth).step();
+        elapse: undefined,
-      const animationData = animation.translateX(-(elapse * speed) / 1000).step();
+        animation: null,
-      this.setData({
+        resetAnimation: null,
-        animationData: resetAnimation.export()
-      });
-      setTimeout(() => {
-        this.setData({
-          animationData: animationData.export()
-        });
-      }, 100);
-
-      const timer = setTimeout(() => {
-        this.scroll();
-      }, elapse);
-
-      this.setData({
-        timer
-      });
-    },
-
-    onClickIcon() {
-      const { timer } = this.data;
-      timer && clearTimeout(timer);
-      this.setData({
-        show: false,
         timer: null
-      });
     },
-
+    watch: {
-    onClick(event) {
+        text() {
-      this.$emit('click', event);
+            this.setData({}, this.init);
+        }
+    },
+    created() {
+        if (this.data.mode) {
+            this.setData({
+                hasRightIcon: true
+            });
+        }
+    },
+    destroyed() {
+        const { timer } = this.data;
+        timer && clearTimeout(timer);
+    },
+    methods: {
+        init() {
+            this.getRect('.van-notice-bar__content').then(rect => {
+                if (!rect || !rect.width) {
+                    return;
+                }
+                this.setData({
+                    width: rect.width
+                });
+                this.getRect('.van-notice-bar__content-wrap').then(rect => {
+                    if (!rect || !rect.width) {
+                        return;
+                    }
+                    const wrapWidth = rect.width;
+                    const { width, speed, scrollable, delay } = this.data;
+                    if (scrollable && wrapWidth < width) {
+                        const elapse = width / speed * 1000;
+                        const animation = wx.createAnimation({
+                            duration: elapse,
+                            timeingFunction: 'linear',
+                            delay
+                        });
+                        const resetAnimation = wx.createAnimation({
+                            duration: 0,
+                            timeingFunction: 'linear'
+                        });
+                        this.setData({
+                            elapse,
+                            wrapWidth,
+                            animation,
+                            resetAnimation
+                        }, () => {
+                            this.scroll();
+                        });
+                    }
+                });
+            });
+        },
+        scroll() {
+            const { animation, resetAnimation, wrapWidth, elapse, speed } = this.data;
+            resetAnimation.translateX(wrapWidth).step();
+            const animationData = animation.translateX(-(elapse * speed) / 1000).step();
+            this.setData({
+                animationData: resetAnimation.export()
+            });
+            setTimeout(() => {
+                this.setData({
+                    animationData: animationData.export()
+                });
+            }, 100);
+            const timer = setTimeout(() => {
+                this.scroll();
+            }, elapse);
+            this.setData({
+                timer
+            });
+        },
+        onClickIcon() {
+            const { timer } = this.data;
+            timer && clearTimeout(timer);
+            this.setData({
+                show: false,
+                timer: null
+            });
+        },
+        onClick(event) {
+            this.$emit('click', event);
+        }
     }
-  }
 });

dist/notify/index.js

@@ -1,43 +1,38 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    props: {
-    text: String,
+        text: String,
-    color: {
+        color: {
-      type: String,
+            type: String,
-      value: '#fff'
+            value: '#fff'
+        },
+        backgroundColor: {
+            type: String,
+            value: '#e64340'
+        },
+        duration: {
+            type: Number,
+            value: 3000
+        }
     },
-    backgroundColor: {
+    methods: {
-      type: String,
+        show() {
-      value: '#e64340'
+            const { duration } = this.data;
-    },
+            clearTimeout(this.timer);
-    duration: {
+            this.setData({
-      type: Number,
+                show: true
-      value: 3000
+            });
+            if (duration > 0 && duration !== Infinity) {
+                this.timer = setTimeout(() => {
+                    this.hide();
+                }, duration);
+            }
+        },
+        hide() {
+            clearTimeout(this.timer);
+            this.setData({
+                show: false
+            });
+        }
     }
-  },
-
-  methods: {
-    show() {
-      const { duration } = this.data;
-
-      clearTimeout(this.timer);
-      this.setData({
-        show: true
-      });
-
-      if (duration > 0 && duration !== Infinity) {
-        this.timer = setTimeout(() => {
-          this.hide();
-        }, duration);
-      }
-    },
-
-    hide() {
-      clearTimeout(this.timer);
-      this.setData({
-        show: false
-      });
-    }
-  }
 });

dist/notify/notify.js

@@ -1,25 +1,19 @@
 import { isObj } from '../common/utils';
-
 const defaultOptions = {
-  selector: '#van-notify',
+    selector: '#van-notify',
-  duration: 3000
+    duration: 3000
 };
-
 function parseOptions(text) {
-  return isObj(text) ? text : { text };
+    return isObj(text) ? text : { text };
 }
-
 export default function Notify(options = {}) {
-  const pages = getCurrentPages();
+    const pages = getCurrentPages();
-  const ctx = pages[pages.length - 1];
+    const ctx = pages[pages.length - 1];
-
+    options = Object.assign({}, defaultOptions, parseOptions(options));
-  options = Object.assign({}, defaultOptions, parseOptions(options));
+    const el = ctx.selectComponent(options.selector);
-
+    delete options.selector;
-  const el = ctx.selectComponent(options.selector);
+    if (el) {
-  delete options.selector;
+        el.setData(options);
-
+        el.show();
-  if (el) {
+    }
-    el.setData(options);
-    el.show();
-  }
 }

dist/overlay/index.js

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

dist/panel/index.js

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

dist/popup/index.js

@@ -1,38 +1,34 @@
 import { VantComponent } from '../common/component';
 import { transition } from '../mixins/transition';
-
 VantComponent({
-  mixins: [transition(false)],
+    mixins: [transition(false)],
-
+    props: {
-  props: {
+        transition: String,
-    transition: String,
+        customStyle: String,
-    customStyle: String,
+        overlayStyle: String,
-    overlayStyle: String,
+        zIndex: {
-    zIndex: {
+            type: Number,
-      type: Number,
+            value: 100
-      value: 100
+        },
+        overlay: {
+            type: Boolean,
+            value: true
+        },
+        closeOnClickOverlay: {
+            type: Boolean,
+            value: true
+        },
+        position: {
+            type: String,
+            value: 'center'
+        }
     },
-    overlay: {
+    methods: {
-      type: Boolean,
+        onClickOverlay() {
-      value: true
+            this.$emit('click-overlay');
-    },
+            if (this.data.closeOnClickOverlay) {
-    closeOnClickOverlay: {
+                this.$emit('close');
-      type: Boolean,
+            }
-      value: true
+        }
-    },
-    position: {
-      type: String,
-      value: 'center'
     }
-  },
-
-  methods: {
-    onClickOverlay() {
-      this.$emit('click-overlay');
-
-      if (this.data.closeOnClickOverlay) {
-        this.$emit('close');
-      }
-    }
-  }
 });

dist/progress/index.js

@@ -1,104 +1,64 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    props: {
-    inactive: {
+        inactive: Boolean,
-      type: Boolean,
+        percentage: Number,
-      observer() {
+        pivotText: String,
-        this.setPivotStyle();
+        pivotColor: String,
-        this.setPortionStyle();
+        showPivot: {
-      }
+            type: Boolean,
+            value: true
+        },
+        color: {
+            type: String,
+            value: '#38f'
+        },
+        textColor: {
+            type: String,
+            value: '#fff'
+        }
     },
-    pivotColor: {
+    data: {
-      type: String,
+        pivotWidth: 0,
-      observer: 'setPivotStyle'
+        progressWidth: 0
     },
-    percentage: {
+    watch: {
-      type: Number,
+        pivotText: 'getWidth',
-      observer() {
+        showPivot: 'getWidth'
-        this.setText();
-        this.setPortionStyle();
-      }
     },
-    showPivot: {
+    computed: {
-      type: Boolean,
+        portionStyle() {
-      value: true,
+            const width = (this.data.progressWidth - this.data.pivotWidth) * this.data.percentage / 100 + 'px';
-      observer: 'getWidth'
+            const background = this.getCurrentColor();
+            return `width: ${width}; background: ${background}; `;
+        },
+        pivotStyle() {
+            const color = this.data.textColor;
+            const background = this.data.pivotColor || this.getCurrentColor();
+            return `color: ${color}; background: ${background}`;
+        },
+        text() {
+            return this.data.pivotText || this.data.percentage + '%';
+        }
     },
-    pivotText: {
+    mounted() {
-      type: String,
-      observer() {
-        this.setText();
         this.getWidth();
-      }
     },
-    color: {
+    methods: {
-      type: String,
+        getCurrentColor() {
-      value: '#38f',
+            return this.data.inactive ? '#cacaca' : this.data.color;
-      observer() {
+        },
-        this.setPivotStyle();
+        getWidth() {
-        this.setPortionStyle();
+            this.getRect('.van-progress').then(rect => {
-      }
+                this.setData({
-    },
+                    progressWidth: rect.width
-    textColor: {
+                });
-      type: String,
+            });
-      value: '#fff',
+            this.getRect('.van-progress__pivot').then(rect => {
-      observer: 'setPivotStyle'
+                this.setData({
+                    pivotWidth: rect.width || 0
+                });
+            });
+        }
     }
-  },
-
-  data: {
-    pivotWidth: 0,
-    progressWidth: 0
-  },
-
-  mounted() {
-    this.setText();
-    this.setPivotStyle();
-    this.getWidth();
-  },
-
-  methods: {
-    getCurrentColor() {
-      return this.data.inactive ? '#cacaca' : this.data.color;
-    },
-
-    setText() {
-      this.setData({
-        text: this.data.pivotText || this.data.percentage + '%'
-      });
-    },
-
-    setPortionStyle() {
-      const width = (this.data.progressWidth - this.data.pivotWidth) * this.data.percentage / 100 + 'px';
-      const background = this.getCurrentColor();
-      this.setData({
-        portionStyle: `width: ${width}; background: ${background}; `
-      });
-    },
-
-    setPivotStyle() {
-      const color = this.data.textColor;
-      const background = this.data.pivotColor || this.getCurrentColor();
-      this.setData({
-        pivotStyle: `color: ${color}; background: ${background}`
-      });
-    },
-
-    getWidth() {
-      this.getRect('.van-progress').then(rect => {
-        this.setData({
-          progressWidth: rect.width
-        });
-        this.setPortionStyle();
-      });
-
-      this.getRect('.van-progress__pivot').then(rect => {
-        this.setData({
-          pivotWidth: rect.width || 0
-        });
-        this.setPortionStyle();
-      });
-    }
-  }
 });

dist/radio-group/index.js

@@ -1,37 +1,32 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  relations: {
+    relation: {
-    '../radio/index': {
+        name: 'radio',
-      type: 'descendant',
+        type: 'descendant',
-      linked(target) {
+        linked(target) {
-        const { value, disabled } = this.data;
+            const { value, disabled } = this.data;
-        target.setData({
+            target.setData({
-          value: value,
+                value: value,
-          disabled: disabled || target.data.disabled
+                disabled: disabled || target.data.disabled
-        });
+            });
-      }
+        }
-    }
-  },
-
-  props: {
-    value: {
-      type: null,
-      observer(value) {
-        const children = this.getRelationNodes('../radio/index');
-        children.forEach(child => {
-          child.setData({ value });
-        });
-      }
     },
-    disabled: {
+    props: {
-      type: Boolean,
+        value: null,
-      observer(disabled) {
+        disabled: Boolean
-        const children = this.getRelationNodes('../radio/index');
+    },
-        children.forEach(child => {
+    watch: {
-          child.setData({ disabled: disabled || children.data.disabled });
+        value(value) {
-        });
+            const children = this.getRelationNodes('../radio/index');
-      }
+            children.forEach(child => {
+                child.setData({ value });
+            });
+        },
+        disabled(disabled) {
+            const children = this.getRelationNodes('../radio/index');
+            children.forEach(child => {
+                child.setData({ disabled: disabled || child.data.disabled });
+            });
+        }
     }
-  }
 });

dist/radio/index.js

@@ -1,49 +1,40 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  relations: {
+    relation: {
-    '../radio-group/index': {
+        name: 'radio-group',
-      type: 'ancestor'
+        type: 'ancestor'
-    }
-  },
-
-  classes: ['icon-class', 'label-class'],
-
-  props: {
-    name: null,
-    value: null,
-    disabled: Boolean,
-    labelDisabled: Boolean,
-    labelPosition: String
-  },
-
-  computed: {
-    iconClass() {
-      const { disabled, name, value } = this.data;
-      return this.classNames('van-radio__icon', {
-        'van-radio__icon--disabled': disabled,
-        'van-radio__icon--checked': !disabled && name === value,
-        'van-radio__icon--check': !disabled && name !== value
-      });
-    }
-  },
-
-  methods: {
-    emitChange(value) {
-      const parent = this.getRelationNodes('../radio-group/index')[0];
-      (parent || this).$emit('input', value);
-      (parent || this).$emit('change', value);
     },
-
+    classes: ['icon-class', 'label-class'],
-    onChange(event) {
+    props: {
-      const { value } = event.detail;
+        name: null,
-      this.emitChange(value);
+        value: null,
+        disabled: Boolean,
+        labelDisabled: Boolean,
+        labelPosition: String
     },
-
+    computed: {
-    onClickLabel() {
+        iconClass() {
-      if (!this.data.disabled && !this.data.labelDisabled) {
+            const { disabled, name, value } = this.data;
-        this.emitChange(this.data.name);
+            return this.classNames('van-radio__icon', {
-      }
+                'van-radio__icon--disabled': disabled,
+                'van-radio__icon--checked': !disabled && name === value,
+                'van-radio__icon--check': !disabled && name !== value
+            });
+        }
+    },
+    methods: {
+        emitChange(value) {
+            const instance = this.getRelationNodes('../radio-group/index')[0] || this;
+            instance.$emit('input', value);
+            instance.$emit('change', value);
+        },
+        onChange(event) {
+            this.emitChange(event.detail.value);
+        },
+        onClickLabel() {
+            if (!this.data.disabled && !this.data.labelDisabled) {
+                this.emitChange(this.data.name);
+            }
+        }
     }
-  }
 });

dist/row/index.js

@@ -1,41 +1,36 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  relations: {
+    relation: {
-    '../col/index': {
+        name: 'col',
-      type: 'descendant',
+        type: 'descendant',
-
+        linked(target) {
-      linked(target) {
+            if (this.data.gutter) {
-        if (this.data.gutter) {
+                target.setGutter(this.data.gutter);
-          target.setGutter(this.data.gutter);
+            }
+        }
+    },
+    props: {
+        gutter: Number
+    },
+    watch: {
+        gutter: 'setGutter'
+    },
+    mounted() {
+        if (this.data.gutter) {
+            this.setGutter();
+        }
+    },
+    methods: {
+        setGutter() {
+            const { gutter } = this.data;
+            const margin = `-${Number(gutter) / 2}px`;
+            const style = gutter
+                ? `margin-right: ${margin}; margin-left: ${margin};`
+                : '';
+            this.setData({ style });
+            this.getRelationNodes('../col/index').forEach(col => {
+                col.setGutter(this.data.gutter);
+            });
         }
-      }
     }
-  },
-
-  props: {
-    gutter: {
-      type: Number,
-      observer: 'setGutter'
-    }
-  },
-
-  mounted() {
-    if (this.data.gutter) {
-      this.setGutter();
-    }
-  },
-
-  methods: {
-    setGutter() {
-      const { gutter } = this.data;
-      const margin = `-${Number(gutter) / 2}px`;
-      const style = gutter ? `margin-right: ${margin}; margin-left: ${margin};` : '';
-
-      this.setData({ style });
-      this.getRelationNodes('../col/index').forEach((col) => {
-        col.setGutter(this.data.gutter);
-      });
-    }
-  }
 });

dist/search/index.js

@@ -1,49 +1,44 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  field: true,
+    field: true,
-
+    classes: ['cancel-class'],
-  classes: ['cancel-class'],
+    props: {
-
+        focus: Boolean,
-  props: {
+        disabled: Boolean,
-    focus: Boolean,
+        readonly: Boolean,
-    disabled: Boolean,
+        showAction: Boolean,
-    readonly: Boolean,
+        useActionSlot: Boolean,
-    showAction: Boolean,
+        placeholder: String,
-    useActionSlot: Boolean,
+        background: {
-    placeholder: String,
+            type: String,
-    background: {
+            value: '#f2f2f2'
-      type: String,
+        },
-      value: '#f2f2f2'
+        maxlength: {
+            type: Number,
+            value: -1
+        }
     },
-    maxlength: {
+    data: {
-      type: Number,
+        value: ''
-      value: -1
+    },
+    methods: {
+        onChange(event) {
+            this.setData({ value: event.detail });
+            this.$emit('change', event.detail);
+        },
+        onCancel() {
+            this.setData({ value: '' });
+            this.$emit('cancel');
+            this.$emit('change', '');
+        },
+        onSearch() {
+            this.$emit('search', this.data.value);
+        },
+        onFocus() {
+            this.$emit('focus');
+        },
+        onBlur() {
+            this.$emit('blur');
+        }
     }
-  },
-
-  methods: {
-    onChange(event) {
-      this.setData({ value: event.detail });
-      this.$emit('change', event.detail);
-    },
-
-    onCancel() {
-      this.setData({ value: '' });
-      this.$emit('cancel');
-      this.$emit('change', '');
-    },
-
-    onSearch() {
-      this.$emit('search', this.data.value);
-    },
-
-    onFocus() {
-      this.$emit('focus');
-    },
-
-    onBlur() {
-      this.$emit('blur');
-    }
-  }
 });

dist/slider/index.js

@@ -1,85 +1,75 @@
 import { VantComponent } from '../common/component';
 import { touch } from '../mixins/touch';
-
 VantComponent({
-  mixins: [touch],
+    mixins: [touch],
-
+    props: {
-  props: {
+        disabled: Boolean,
-    disabled: Boolean,
+        max: {
-    max: {
+            type: Number,
-      type: Number,
+            value: 100
-      value: 100
+        },
+        min: {
+            type: Number,
+            value: 0
+        },
+        step: {
+            type: Number,
+            value: 1
+        },
+        value: {
+            type: Number,
+            value: 0
+        },
+        barHeight: {
+            type: String,
+            value: '2px'
+        }
     },
-    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: {
+            this.touchStart(event);
-      type: Number,
+            this.startValue = this.format(this.data.value);
-      value: 0
+        },
-    },
+        onTouchMove(event) {
-    barHeight: {
+            if (this.data.disabled)
-      type: String,
+                return;
-      value: '2px'
+            this.touchMove(event);
+            this.getRect('.van-slider').then(rect => {
+                const diff = this.deltaX / rect.width * 100;
+                this.updateValue(this.startValue + diff);
+            });
+        },
+        onTouchEnd() {
+            if (this.data.disabled)
+                return;
+            this.updateValue(this.data.value, true);
+        },
+        onClick(event) {
+            if (this.data.disabled)
+                return;
+            this.getRect(rect => {
+                const value = (event.detail.x - rect.left) / rect.width * 100;
+                this.updateValue(value, true);
+            });
+        },
+        updateValue(value, end) {
+            value = this.format(value);
+            this.setData({
+                value,
+                barStyle: `width: ${value}%; height: ${this.data.barHeight};`
+            });
+            if (end) {
+                this.$emit('change', value);
+            }
+        },
+        format(value) {
+            const { max, min, step } = this.data;
+            return Math.round(Math.max(min, Math.min(value, max)) / step) * step;
+        }
     }
-  },
-
-  created() {
-    this.updateValue(this.data.value);
-  },
-
-  methods: {
-    onTouchStart(event) {
-      if (this.data.disabled) return;
-
-      this.touchStart(event);
-      this.startValue = this.format(this.data.value);
-    },
-
-    onTouchMove(event) {
-      if (this.data.disabled) return;
-
-      this.touchMove(event);
-      this.getRect('.van-slider').then(rect => {
-        const diff = this.deltaX / rect.width * 100;
-        this.updateValue(this.startValue + diff);
-      });
-    },
-
-    onTouchEnd() {
-      if (this.data.disabled) return;
-      this.updateValue(this.data.value, true);
-    },
-
-    onClick(event) {
-      if (this.data.disabled) return;
-
-      this.getRect(rect => {
-        const value = (event.detail.x - rect.left) / rect.width * 100;
-        this.updateValue(value, true);
-      });
-    },
-
-    updateValue(value, end) {
-      value = this.format(value);
-
-      this.setData({
-        value,
-        barStyle: `width: ${value}%; height: ${this.data.barHeight};`
-      });
-
-      if (end) {
-        this.$emit('change', value);
-      }
-    },
-
-    format(value) {
-      const { max, min, step } = this.data;
-      return Math.round(Math.max(min, Math.min(value, max)) / step) * step;
-    }
-  }
 });

dist/stepper/index.js

@@ -1,82 +1,72 @@
 import { VantComponent } from '../common/component';
-
 // Note that the bitwise operators and shift operators operate on 32-bit ints
 // so in that case, the max safe integer is 2^31-1, or 2147483647
 const MAX = 2147483647;
-
 VantComponent({
-  field: true,
+    field: true,
-
+    classes: [
-  classes: [
+        'input-class',
-    'input-class',
+        'plus-class',
-    'plus-class',
+        'minus-class'
-    'minus-class'
+    ],
-  ],
+    props: {
-
+        integer: Boolean,
-  props: {
+        disabled: Boolean,
-    integer: Boolean,
+        disableInput: Boolean,
-    disabled: Boolean,
+        min: {
-    disableInput: Boolean,
+            type: null,
-    min: {
+            value: 1
-      type: null,
+        },
-      value: 1
+        max: {
+            type: null,
+            value: MAX
+        },
+        step: {
+            type: null,
+            value: 1
+        }
     },
-    max: {
+    data: {
-      type: null,
+        value: 0
-      value: MAX
     },
-    step: {
+    created() {
-      type: null,
+        this.setData({
-      value: 1
+            value: this.range(this.data.value)
+        });
+    },
+    methods: {
+        // limit value range
+        range(value) {
+            return Math.max(Math.min(this.data.max, value), this.data.min);
+        },
+        onInput(event) {
+            const { value = '' } = event.detail || {};
+            this.triggerInput(value);
+        },
+        onChange(type) {
+            if (this[`${type}Disabled`]) {
+                this.$emit('overlimit', type);
+                return;
+            }
+            const diff = type === 'minus' ? -this.data.step : +this.data.step;
+            const value = Math.round((this.data.value + diff) * 100) / 100;
+            this.triggerInput(this.range(value));
+            this.$emit(type);
+        },
+        onBlur(event) {
+            const value = this.range(this.data.value);
+            this.triggerInput(value);
+            this.$emit('blur', event);
+        },
+        onMinus() {
+            this.onChange('minus');
+        },
+        onPlus() {
+            this.onChange('plus');
+        },
+        triggerInput(value) {
+            this.setData({ value });
+            this.$emit('change', value);
+        }
     }
-  },
-
-  created() {
-    this.setData({
-      value: this.range(this.data.value)
-    });
-  },
-
-  methods: {
-    // limit value range
-    range(value) {
-      return Math.max(Math.min(this.data.max, value), this.data.min);
-    },
-
-    onInput(event) {
-      const { value = '' } = event.detail || {};
-      this.triggerInput(value);
-    },
-
-    onChange(type) {
-      if (this[`${type}Disabled`]) {
-        this.$emit('overlimit', type);
-        return;
-      }
-
-      const diff = type === 'minus' ? -this.data.step : +this.data.step;
-      const value = Math.round((this.data.value + diff) * 100) / 100;
-      this.triggerInput(this.range(value));
-      this.$emit(type);
-    },
-
-    onBlur(event) {
-      const value = this.range(this.data.value);
-      this.triggerInput(value);
-      this.$emit('blur', event);
-    },
-
-    onMinus() {
-      this.onChange('minus');
-    },
-
-    onPlus() {
-      this.onChange('plus');
-    },
-
-    triggerInput(value) {
-      this.setData({ value });
-      this.$emit('change', value);
-    }
-  }
 });

dist/steps/index.js

@@ -1,49 +1,42 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    props: {
-    icon: String,
+        icon: String,
-    steps: {
+        steps: Array,
-      type: Array,
+        active: Number,
-      observer: 'formatSteps'
+        direction: {
+            type: String,
+            value: 'horizontal'
+        },
+        activeColor: {
+            type: String,
+            value: '#06bf04'
+        }
     },
-    active: {
+    watch: {
-      type: Number,
+        steps: 'formatSteps',
-      observer: 'formatSteps'
+        active: 'formatSteps'
     },
-    direction: {
+    created() {
-      type: String,
+        this.formatSteps();
-      value: 'horizontal'
     },
-    activeColor: {
+    methods: {
-      type: String,
+        formatSteps() {
-      value: '#06bf04'
+            const { steps } = this.data;
+            steps.forEach((step, index) => {
+                step.status = this.getStatus(index);
+            });
+            this.setData({ steps });
+        },
+        getStatus(index) {
+            const { active } = this.data;
+            if (index < active) {
+                return 'finish';
+            }
+            else if (index === active) {
+                return 'process';
+            }
+            return '';
+        }
     }
-  },
-
-  created() {
-    this.formatSteps();
-  },
-
-  methods: {
-    formatSteps() {
-      const { steps } = this.data;
-      steps.forEach((step, index) => {
-        step.status = this.getStatus(index);
-      });
-      this.setData({ steps });
-    },
-
-    getStatus(index) {
-      const { active } = this.data;
-
-      if (index < active) {
-        return 'finish';
-      } else if (index === active) {
-        return 'process';
-      }
-
-      return '';
-    }
-  }
 });

dist/submit-bar/index.js

@@ -1,48 +1,42 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  classes: [
+    classes: [
-    'bar-class',
+        'bar-class',
-    'price-class',
+        'price-class',
-    'button-class'
+        'button-class'
-  ],
+    ],
-
+    props: {
-  props: {
+        tip: [String, Boolean],
-    tip: [String, Boolean],
+        type: Number,
-    type: Number,
+        price: null,
-    price: null,
+        label: String,
-    label: String,
+        loading: Boolean,
-    loading: Boolean,
+        disabled: Boolean,
-    disabled: Boolean,
+        buttonText: String,
-    buttonText: String,
+        currency: {
-    currency: {
+            type: String,
-      type: String,
+            value: '¥'
-      value: '¥'
+        },
+        buttonType: {
+            type: String,
+            value: 'danger'
+        }
     },
-    buttonType: {
+    computed: {
-      type: String,
+        hasPrice() {
-      value: 'danger'
+            return typeof this.data.price === 'number';
-    }
+        },
-  },
+        priceStr() {
-
+            return (this.data.price / 100).toFixed(2);
-  computed: {
+        },
-    hasPrice() {
+        tipStr() {
-      return typeof this.data.price === 'number';
+            const { tip } = this.data;
+            return typeof tip === 'string' ? tip : '';
+        }
     },
-
+    methods: {
-    priceStr() {
+        onSubmit(event) {
-      return (this.data.price / 100).toFixed(2);
+            this.$emit('submit', event.detail);
-    },
+        }
-
-    tipStr() {
-      const { tip } = this.data;
-      return typeof tip === 'string' ? tip : '';
     }
-  },
-
-  methods: {
-    onSubmit(event) {
-      this.$emit('submit', event.detail);
-    }
-  }
 });

dist/switch-cell/index.js

@@ -1,32 +1,28 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  field: true,
+    field: true,
-
+    props: {
-  props: {
+        title: String,
-    title: String,
+        border: Boolean,
-    border: Boolean,
+        checked: Boolean,
-    loading: Boolean,
+        loading: Boolean,
-    disabled: Boolean,
+        disabled: Boolean,
-    checked: {
+        size: {
-      type: Boolean,
+            type: String,
-      observer(value) {
+            value: '26px'
-        this.setData({ value });
+        }
-      }
     },
-    size: {
+    watch: {
-      type: String,
+        checked(value) {
-      value: '26px'
+            this.setData({ value });
+        }
+    },
+    created() {
+        this.setData({ value: this.data.checked });
+    },
+    methods: {
+        onChange(event) {
+            this.$emit('change', event.detail);
+        }
     }
-  },
-
-  created() {
-    this.setData({ value: this.data.checked });
-  },
-
-  methods: {
-    onChange(event) {
-      this.$emit('change', event.detail);
-    }
-  }
 });

dist/switch/index.js

@@ -1,36 +1,31 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  field: true,
+    field: true,
-
+    classes: ['node-class'],
-  classes: ['node-class'],
+    props: {
-
+        checked: Boolean,
-  props: {
+        loading: Boolean,
-    loading: Boolean,
+        disabled: Boolean,
-    disabled: Boolean,
+        size: {
-    checked: {
+            type: String,
-      type: Boolean,
+            value: '30px'
-      observer(value) {
+        }
-        this.setData({ value });
-      }
     },
-    size: {
+    watch: {
-      type: String,
+        checked(value) {
-      value: '30px'
+            this.setData({ value });
+        }
+    },
+    created() {
+        this.setData({ value: this.data.checked });
+    },
+    methods: {
+        onClick() {
+            if (!this.data.disabled && !this.data.loading) {
+                const checked = !this.data.checked;
+                this.$emit('input', checked);
+                this.$emit('change', checked);
+            }
+        }
     }
-  },
-
-  created() {
-    this.setData({ value: this.data.checked });
-  },
-
-  methods: {
-    onClick() {
-      if (!this.data.disabled && !this.data.loading) {
-        const checked = !this.data.checked;
-        this.$emit('input', checked);
-        this.$emit('change', checked);
-      }
-    }
-  }
 });

dist/tab/index.js

@@ -1,36 +1,30 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    relation: {
-    disabled: {
+        name: 'tabs',
-      type: Boolean,
+        type: 'ancestor'
-      observer() {
-        const parent = this.getRelationNodes('../tabs/index')[0];
-        if (parent) {
-          parent.updateTabs();
-        }
-      }
     },
-    title: {
+    props: {
-      type: String,
+        title: String,
-      observer() {
+        disabled: Boolean
-        const parent = this.getRelationNodes('../tabs/index')[0];
+    },
-        if (parent) {
+    data: {
-          parent.setLine();
+        inited: false,
-          parent.updateTabs();
+        active: false
+    },
+    watch: {
+        disabled() {
+            const parent = this.getRelationNodes('../tabs/index')[0];
+            if (parent) {
+                parent.updateTabs();
+            }
+        },
+        title() {
+            const parent = this.getRelationNodes('../tabs/index')[0];
+            if (parent) {
+                parent.setLine();
+                parent.updateTabs();
+            }
         }
-      }
     }
-  },
-
-  relations: {
-    '../tabs/index': {
-      type: 'ancestor'
-    }
-  },
-
-  data: {
-    inited: false,
-    active: false
-  }
 });

dist/tabbar-item/index.js

@@ -1,37 +1,31 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    props: {
-    info: null,
+        info: null,
-    icon: String,
+        icon: String,
-    dot: Boolean
+        dot: Boolean
-  },
-
-  relations: {
-    '../tabbar/index': {
-      type: 'ancestor'
-    }
-  },
-
-  data: {
-    active: false,
-    count: 0
-  },
-
-  methods: {
-    onClick() {
-      const parent = this.getRelationNodes('../tabbar/index')[0];
-      if (parent) {
-        parent.onChange(this);
-      }
-      this.$emit('click');
     },
-
+    relation: {
-    setActive(data) {
+        name: 'tabbar',
-      const { active, count } = this.data;
+        type: 'ancestor'
-      if (active !== data.active || count !== data.count) {
+    },
-        this.setData(data);
+    data: {
-      }
+        active: false,
+        count: 0
+    },
+    methods: {
+        onClick() {
+            const parent = this.getRelationNodes('../tabbar/index')[0];
+            if (parent) {
+                parent.onChange(this);
+            }
+            this.$emit('click');
+        },
+        setActive(data) {
+            const { active, count } = this.data;
+            if (active !== data.active || count !== data.count) {
+                this.setData(data);
+            }
+        }
     }
-  }
 });

dist/tabbar/index.js

@@ -1,70 +1,61 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    relation: {
-    active: {
+        name: 'tabbar-item',
-      type: Number,
+        type: 'descendant',
-      observer(active) {
+        linked(target) {
-        this.setData({ currentActive: active });
+            this.data.items.push(target);
-        this.setActiveItem();
+            setTimeout(() => {
-      }
+                this.setActiveItem();
+            });
+        },
+        unlinked(target) {
+            this.data.items = this.data.items.filter(item => item !== target);
+            setTimeout(() => {
+                this.setActiveItem();
+            });
+        }
     },
-    fixed: {
+    props: {
-      type: Boolean,
+        active: Number,
-      value: true
+        fixed: {
+            type: Boolean,
+            value: true
+        },
+        zIndex: {
+            type: Number,
+            value: 1
+        }
     },
-    zIndex: {
+    data: {
-      type: Number,
+        items: [],
-      value: 1
+        currentActive: -1
-    }
-  },
-
-  data: {
-    items: [],
-    currentActive: -1
-  },
-
-  created() {
-    this.setData({ currentActive: this.data.active });
-  },
-
-  relations: {
-    '../tabbar-item/index': {
-      type: 'descendant',
-
-      linked(target) {
-        this.data.items.push(target);
-        setTimeout(() => {
-          this.setActiveItem();
-        });
-      },
-
-      unlinked(target) {
-        this.data.items = this.data.items.filter(item => item !== target);
-        setTimeout(() => {
-          this.setActiveItem();
-        });
-      }
-    }
-  },
-
-  methods: {
-    setActiveItem() {
-      this.data.items.forEach((item, index) => {
-        item.setActive({
-          active: index === this.data.currentActive,
-          count: this.data.items.length
-        });
-      });
     },
-
+    watch: {
-    onChange(child) {
+        active(active) {
-      const active = this.data.items.indexOf(child);
+            this.setData({ currentActive: active });
-      if (active !== this.data.currentActive && active !== -1) {
+            this.setActiveItem();
-        this.$emit('change', active);
+        }
-        this.setData({ currentActive: active });
+    },
-        this.setActiveItem();
+    created() {
-      }
+        this.setData({ currentActive: this.data.active });
+    },
+    methods: {
+        setActiveItem() {
+            this.data.items.forEach((item, index) => {
+                item.setActive({
+                    active: index === this.data.currentActive,
+                    count: this.data.items.length
+                });
+            });
+        },
+        onChange(child) {
+            const active = this.data.items.indexOf(child);
+            if (active !== this.data.currentActive && active !== -1) {
+                this.$emit('change', active);
+                this.setData({ currentActive: active });
+                this.setActiveItem();
+            }
+        }
     }
-  }
 });

dist/tabs/index.js

@@ -1,175 +1,154 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  relations: {
+    relation: {
-    '../tab/index': {
+        name: 'tab',
-      type: 'descendant',
+        type: 'descendant',
-
+        linked(child) {
-      linked(child) {
+            this.data.tabs.push({
-        this.data.tabs.push({
+                instance: child,
-          instance: child,
+                data: child.data
-          data: child.data
+            });
-        });
+            this.updateTabs();
-        this.updateTabs();
+        },
-      },
+        unlinked(child) {
-
+            const tabs = this.data.tabs.filter(item => item.instance !== child);
-      unlinked(child) {
+            this.setData({
-        const tabs = this.data.tabs.filter(item => item.instance !== child);
+                tabs,
-        this.setData({
+                scrollable: tabs.length > this.data.swipeThreshold
-          tabs,
+            });
-          scrollable: tabs.length > this.data.swipeThreshold
+            this.setActiveTab();
-        });
+        }
-        this.setActiveTab();
-      }
-    }
-  },
-
-  props: {
-    color: {
-      type: String,
-      observer: 'setLine'
     },
-    lineWidth: {
+    props: {
-      type: Number,
+        color: String,
-      observer: 'setLine'
+        lineWidth: Number,
+        active: {
+            type: null,
+            value: 0
+        },
+        type: {
+            type: String,
+            value: 'line'
+        },
+        border: {
+            type: Boolean,
+            value: true
+        },
+        duration: {
+            type: Number,
+            value: 0.2
+        },
+        swipeThreshold: {
+            type: Number,
+            value: 4
+        }
     },
-    active: {
+    data: {
-      type: null,
+        tabs: [],
-      value: 0,
+        lineStyle: '',
-      observer: 'setActiveTab'
+        scrollLeft: 0,
+        scrollable: false
     },
-    type: {
+    watch: {
-      type: String,
+        swipeThreshold() {
-      value: 'line'
+            this.setData({
+                scrollable: this.data.tabs.length > this.data.swipeThreshold
+            });
+        },
+        color: 'setLine',
+        lineWidth: 'setLine',
+        active: 'setActiveTab'
     },
-    border: {
+    mounted() {
-      type: Boolean,
+        this.setLine();
-      value: true
+        this.scrollIntoView();
     },
-    duration: {
+    methods: {
-      type: Number,
+        updateTabs() {
-      value: 0.2
+            const { tabs } = this.data;
-    },
+            this.setData({
-    swipeThreshold: {
+                tabs,
-      type: Number,
+                scrollable: tabs.length > this.data.swipeThreshold
-      value: 4,
+            });
-      observer() {
+            this.setActiveTab();
-        this.setData({
+        },
-          scrollable: this.data.tabs.length > this.data.swipeThreshold
+        trigger(eventName, index) {
-        });
+            this.$emit(eventName, {
-      }
+                index,
-    }
+                title: this.data.tabs[index].data.title
-  },
+            });
-
+        },
-  data: {
+        onTap(event) {
-    tabs: [],
+            const { index } = event.currentTarget.dataset;
-    lineStyle: '',
+            if (this.data.tabs[index].data.disabled) {
-    scrollLeft: 0
+                this.trigger('disabled', index);
-  },
+            }
-
+            else {
-  mounted() {
+                this.trigger('click', index);
-    this.setLine();
+                this.setActive(index);
-    this.scrollIntoView();
+            }
-  },
+        },
-
+        setActive(active) {
-  methods: {
+            if (active !== this.data.active) {
-    updateTabs() {
+                this.trigger('change', active);
-      const { tabs } = this.data;
+                this.setData({ active });
-      this.setData({
+                this.setActiveTab();
-        tabs,
+            }
-        scrollable: tabs.length > this.data.swipeThreshold
+        },
-      });
+        setLine() {
-      this.setActiveTab();
+            if (this.data.type !== 'line') {
-    },
+                return;
-
+            }
-    trigger(eventName, index) {
+            this.getRect('.van-tab', true).then(rects => {
-      this.$emit(eventName, {
+                const rect = rects[this.data.active];
-        index,
+                const width = this.data.lineWidth || rect.width;
-        title: this.data.tabs[index].data.title
+                let left = rects
-      });
+                    .slice(0, this.data.active)
-    },
+                    .reduce((prev, curr) => prev + curr.width, 0);
-
+                left += (rect.width - width) / 2;
-    onTap(event) {
+                this.setData({
-      const { index } = event.currentTarget.dataset;
+                    lineStyle: `
-      if (this.data.tabs[index].data.disabled) {
-        this.trigger('disabled', index);
-      } else {
-        this.trigger('click', index);
-        this.setActive(index);
-      }
-    },
-
-    setActive(active) {
-      if (active !== this.data.active) {
-        this.trigger('change', active);
-        this.setData({ active });
-        this.setActiveTab();
-      }
-    },
-
-    setLine() {
-      if (this.data.type !== 'line') {
-        return;
-      }
-
-      this.getRect('.van-tab', true).then(rects => {
-        const rect = rects[this.data.active];
-        const width = this.data.lineWidth || rect.width;
-        let left = rects
-          .slice(0, this.data.active)
-          .reduce((prev, curr) => prev + curr.width, 0);
-        left += (rect.width - width) / 2;
-
-        this.setData({
-          lineStyle: `
             width: ${width}px;
             background-color: ${this.data.color};
             transform: translateX(${left}px);
             transition-duration: ${this.data.duration}s;
           `
-        });
+                });
-      });
+            });
-    },
+        },
-
+        setActiveTab() {
-    setActiveTab() {
+            this.data.tabs.forEach((item, index) => {
-      this.data.tabs.forEach((item, index) => {
+                const data = {
-        const data = {
+                    active: index === this.data.active
-          active: index === this.data.active
+                };
-        };
+                if (data.active) {
-
+                    data.inited = true;
-        if (data.active) {
+                }
-          data.inited = true;
+                if (data.active !== item.instance.data.active) {
+                    item.instance.setData(data);
+                }
+            });
+            this.setLine();
+            this.scrollIntoView();
+        },
+        // scroll active tab into view
+        scrollIntoView(immediate) {
+            if (!this.data.scrollable) {
+                return;
+            }
+            this.getRect('.van-tab', true).then(tabRects => {
+                const tabRect = tabRects[this.data.active];
+                const offsetLeft = tabRects
+                    .slice(0, this.data.active)
+                    .reduce((prev, curr) => prev + curr.width, 0);
+                const tabWidth = tabRect.width;
+                this.getRect('.van-tabs__nav').then(navRect => {
+                    const navWidth = navRect.width;
+                    this.setData({
+                        scrollLeft: offsetLeft - (navWidth - tabWidth) / 2
+                    });
+                });
+            });
         }
-
-        if (data.active !== item.instance.data.active) {
-          item.instance.setData(data);
-        }
-      });
-
-      this.setLine();
-      this.scrollIntoView();
-    },
-
-    // scroll active tab into view
-    scrollIntoView(immediate) {
-      if (!this.data.scrollable) {
-        return;
-      }
-
-      this.getRect('.van-tab', true).then(tabRects => {
-        const tabRect = tabRects[this.data.active];
-        const offsetLeft = tabRects
-          .slice(0, this.data.active)
-          .reduce((prev, curr) => prev + curr.width, 0);
-        const tabWidth = tabRect.width;
-
-        this.getRect('.van-tabs__nav').then(navRect => {
-          const navWidth = navRect.width;
-          this.setData({
-            scrollLeft: offsetLeft - (navWidth - tabWidth) / 2
-          });
-        });
-      });
     }
-  }
 });

dist/tag/index.js

@@ -1,9 +1,8 @@
 import { VantComponent } from '../common/component';
-
 VantComponent({
-  props: {
+    props: {
-    type: String,
+        type: String,
-    mark: Boolean,
+        mark: Boolean,
-    plain: Boolean
+        plain: Boolean
-  }
+    }
 });

dist/toast/index.js

@@ -1,37 +1,34 @@
 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,
+        clear() {
-      value: 'text'
+            this.setData({
-    },
+                show: false
-    loadingType: {
+            });
-      type: String,
+        },
-      value: 'circular'
+        // for prevent touchmove
-    },
+        noop() { }
-    position: {
-      type: String,
-      value: 'middle'
     }
-  },
-
-  methods: {
-    clear() {
-      this.setData({
-        show: false
-      });
-    },
-
-    // for prevent touchmove
-    noop() {}
-  }
 });

dist/toast/toast.js

@@ -1,72 +1,52 @@
 import { isObj } from '../common/utils';
-
 const defaultOptions = {
-  type: 'text',
+    type: 'text',
-  mask: false,
+    mask: false,
-  message: '',
+    message: '',
-  show: true,
+    show: true,
-  zIndex: 1000,
+    zIndex: 1000,
-  duration: 3000,
+    duration: 3000,
-  position: 'middle',
+    position: 'middle',
-  forbidClick: false,
+    forbidClick: false,
-  loadingType: 'circular',
+    loadingType: 'circular',
-  selector: '#van-toast'
+    selector: '#van-toast'
 };
-
 let queue = [];
-let currentOptions = { ...defaultOptions };
+let currentOptions = Object.assign({}, defaultOptions);
-
 function parseOptions(message) {
-  return isObj(message) ? message : { message };
+    return isObj(message) ? message : { message };
 }
-
+const Toast = (options = {}) => {
-function Toast(options = {}) {
+    options = Object.assign({}, currentOptions, parseOptions(options));
-  options = {
+    const pages = getCurrentPages();
-    ...currentOptions,
+    const ctx = pages[pages.length - 1];
-    ...parseOptions(options)
+    const toast = ctx.selectComponent(options.selector);
-  };
+    delete options.selector;
-
+    queue.push(toast);
-  const pages = getCurrentPages();
+    toast.setData(options);
-  const ctx = pages[pages.length - 1];
+    clearTimeout(toast.timer);
-
+    if (options.duration > 0) {
-  const toast = ctx.selectComponent(options.selector);
+        toast.timer = setTimeout(() => {
-  delete options.selector;
+            toast.clear();
-
+            queue = queue.filter(item => item !== toast);
-  queue.push(toast);
+        }, options.duration);
-  toast.setData(options);
+    }
-  clearTimeout(toast.timer);
+    return toast;
-
-  if (options.duration > 0) {
-    toast.timer = setTimeout(() => {
-      toast.clear();
-      queue = queue.filter(item => item !== toast);
-    }, options.duration);
-  }
-
-  return toast;
 };
-
+const createMethod = type => options => Toast(Object.assign({ type }, parseOptions(options)));
-const createMethod = type => options => Toast({
-  type, ...parseOptions(options)
-});
-
 ['loading', 'success', 'fail'].forEach(method => {
-  Toast[method] = createMethod(method);
+    Toast[method] = createMethod(method);
 });
-
+Toast.clear = () => {
-Toast.clear = all => {
+    queue.forEach(toast => {
-  queue.forEach(toast => {
+        toast.clear();
-    toast.clear();
+    });
-  });
+    queue = [];
-  queue = [];
 };
-
 Toast.setDefaultOptions = options => {
-  Object.assign(currentOptions, options);
+    Object.assign(currentOptions, options);
 };
-
 Toast.resetDefaultOptions = () => {
-  currentOptions = { ...defaultOptions };
+    currentOptions = Object.assign({}, defaultOptions);
 };
-
 export default Toast;

dist/transition/index.js

@@ -1,13 +1,11 @@
 import { VantComponent } from '../common/component';
 import { transition } from '../mixins/transition';
-
 VantComponent({
-  mixins: [transition(true)],
+    mixins: [transition(true)],
-
+    props: {
-  props: {
+        name: {
-    name: {
+            type: String,
-      type: String,
+            value: 'fade'
-      value: 'fade'
+        }
     }
-  }
 });

dist/tree-select/index.js

@@ -1,72 +1,63 @@
 import { VantComponent } from '../common/component';
-
 const ITEM_HEIGHT = 44;
-
 VantComponent({
-  props: {
+    props: {
-    items: {
+        items: Array,
-      type: Array,
+        mainActiveIndex: {
-      observer() {
+            type: Number,
-        this.updateSubItems();
+            value: 0
-        this.updateMainHeight();
+        },
-      }
+        activeId: {
+            type: Number,
+            value: 0
+        },
+        maxHeight: {
+            type: Number,
+            value: 300
+        }
     },
-    mainActiveIndex: {
+    data: {
-      type: Number,
+        subItems: [],
-      value: 0,
+        mainHeight: 0,
-      observer: 'updateSubItems'
+        itemHeight: 0
     },
-    activeId: {
+    watch: {
-      type: Number,
+        items() {
-      value: 0
+            this.updateSubItems();
+            this.updateMainHeight();
+        },
+        maxHeight() {
+            this.updateItemHeight();
+            this.updateMainHeight();
+        },
+        mainActiveIndex: 'updateSubItems'
     },
-    maxHeight: {
+    methods: {
-      type: Number,
+        // 当一个子项被选择时
-      value: 300,
+        onSelectItem(event) {
-      observer() {
+            this.$emit('click-item', event.currentTarget.dataset.item);
-        this.updateItemHeight();
+        },
-        this.updateMainHeight();
+        // 当一个导航被点击时
-      }
+        onClickNav(event) {
+            const { index } = event.currentTarget.dataset;
+            this.$emit('click-nav', { index });
+        },
+        // 更新子项列表
+        updateSubItems() {
+            const selectedItem = this.data.items[this.data.mainActiveIndex] || {};
+            this.setData({ subItems: selectedItem.children || [] });
+            this.updateItemHeight();
+        },
+        // 更新组件整体高度，根据最大高度和当前组件需要展示的高度来决定
+        updateMainHeight() {
+            const maxHeight = Math.max(this.data.items.length * ITEM_HEIGHT, this.data.subItems.length * ITEM_HEIGHT);
+            this.setData({ mainHeight: Math.min(maxHeight, this.data.maxHeight) });
+        },
+        // 更新子项列表高度，根据可展示的最大高度和当前子项列表的高度决定
+        updateItemHeight() {
+            this.setData({
+                itemHeight: Math.min(this.data.subItems.length * ITEM_HEIGHT, this.data.maxHeight)
+            });
+        }
     }
-  },
-
-  data: {
-    subItems: [],
-    mainHeight: 0,
-    itemHeight: 0
-  },
-
-  methods: {
-    // 当一个子项被选择时
-    onSelectItem(event) {
-      this.$emit('click-item', event.currentTarget.dataset.item);
-    },
-
-    // 当一个导航被点击时
-    onClickNav(event) {
-      const { index } = event.currentTarget.dataset;
-      this.$emit('click-nav', { index });
-    },
-
-    // 更新子项列表
-    updateSubItems() {
-      const selectedItem = this.data.items[this.data.mainActiveIndex] || {};
-
-      this.setData({ subItems: selectedItem.children || [] });
-
-      this.updateItemHeight();
-    },
-
-    // 更新组件整体高度，根据最大高度和当前组件需要展示的高度来决定
-    updateMainHeight() {
-      const maxHeight = Math.max(this.data.items.length * ITEM_HEIGHT, this.data.subItems.length * ITEM_HEIGHT);
-
-      this.setData({ mainHeight: Math.min(maxHeight, this.data.maxHeight) });
-    },
-
-    // 更新子项列表高度，根据可展示的最大高度和当前子项列表的高度决定
-    updateItemHeight() {
-      this.setData({ itemHeight: Math.min(this.data.subItems.length * ITEM_HEIGHT, this.data.maxHeight) });
-    }
-  }
 });