blackteay/vant-weapp
1
0
Fork 0
mirror of https://gitee.com/vant-contrib/vant-weapp.git synced 2025-04-05 19:41:45 +08:00
Code Issues Projects Releases Wiki Activity

build: compile 1.3.0

Browse Source
This commit is contained in:
rex 2020-05-08 14:31:59 +08:00
parent dd1adc288f
commit e2e4538453
220 changed files with 12317 additions and 11320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
dist/action-sheet/index.js vendored
View File

@ -2,61 +2,61 @@ import { VantComponent } from '../common/component';
import { button } from '../mixins/button'; import { button } from '../mixins/button';
import { openType } from '../mixins/open-type'; import { openType } from '../mixins/open-type';
VantComponent({ VantComponent({
mixins: [button, openType], mixins: [button, openType],
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
}
}, },
methods: { zIndex: {
onSelect(event) { type: Number,
const { index } = event.currentTarget.dataset; value: 100,
const item = this.data.actions[index]; },
if (item && !item.disabled && !item.loading) { actions: {
this.$emit('select', item); type: Array,
if (this.data.closeOnClickAction) { value: [],
this.onClose(); },
} overlay: {
} type: Boolean,
}, value: true,
onCancel() { },
this.$emit('cancel'); closeOnClickOverlay: {
}, type: Boolean,
onClose() { value: true,
this.$emit('close'); },
}, closeOnClickAction: {
onClickOverlay() { type: Boolean,
this.$emit('click-overlay'); value: true,
this.onClose(); },
safeAreaInsetBottom: {
type: Boolean,
value: true,
},
},
methods: {
onSelect(event) {
const { index } = event.currentTarget.dataset;
const item = this.data.actions[index];
if (item && !item.disabled && !item.loading) {
this.$emit('select', item);
if (this.data.closeOnClickAction) {
this.onClose();
} }
} }
},
onCancel() {
this.$emit('cancel');
},
onClose() {
this.$emit('close');
},
onClickOverlay() {
this.$emit('click-overlay');
this.onClose();
},
},
}); });

418
dist/area/index.js vendored
View File

@ -2,209 +2,223 @@ import { VantComponent } from '../common/component';
import { pickerProps } from '../picker/shared'; import { pickerProps } from '../picker/shared';
const COLUMNSPLACEHOLDERCODE = '000000'; const COLUMNSPLACEHOLDERCODE = '000000';
VantComponent({ VantComponent({
classes: ['active-class', 'toolbar-class', 'column-class'], classes: ['active-class', 'toolbar-class', 'column-class'],
props: Object.assign(Object.assign({}, pickerProps), { value: { props: Object.assign(Object.assign({}, pickerProps), {
type: String, value: {
observer(value) { type: String,
this.code = value; observer(value) {
this.setValues(); this.code = value;
}, this.setValues();
}, areaList: { },
type: Object,
value: {},
observer: 'setValues'
}, columnsNum: {
type: null,
value: 3,
observer(value) {
this.setData({
displayColumns: this.data.columns.slice(0, +value)
});
}
}, columnsPlaceholder: {
type: Array,
observer(val) {
this.setData({
typeToColumnsPlaceholder: {
province: val[0] || '',
city: val[1] || '',
county: val[2] || '',
}
});
}
} }),
data: {
columns: [{ values: [] }, { values: [] }, { values: [] }],
displayColumns: [{ values: [] }, { values: [] }, { values: [] }],
typeToColumnsPlaceholder: {}
}, },
mounted() { areaList: {
setTimeout(() => { type: Object,
this.setValues(); value: {},
}, 0); observer: 'setValues',
}, },
methods: { columnsNum: {
getPicker() { type: null,
if (this.picker == null) { value: 3,
this.picker = this.selectComponent('.van-area__picker'); observer(value) {
} this.setData({
return this.picker; displayColumns: this.data.columns.slice(0, +value),
}, });
onCancel(event) { },
this.emit('cancel', event.detail); },
}, columnsPlaceholder: {
onConfirm(event) { type: Array,
const { index } = event.detail; observer(val) {
let { value } = event.detail; this.setData({
value = this.parseOutputValues(value); typeToColumnsPlaceholder: {
this.emit('confirm', { value, index }); province: val[0] || '',
}, city: val[1] || '',
emit(type, detail) { county: val[2] || '',
detail.values = detail.value; },
delete detail.value; });
this.$emit(type, detail); },
}, },
// parse output columns data }),
parseOutputValues(values) { data: {
const { columnsPlaceholder } = this.data; columns: [{ values: [] }, { values: [] }, { values: [] }],
return values.map((value, index) => { displayColumns: [{ values: [] }, { values: [] }, { values: [] }],
// save undefined value typeToColumnsPlaceholder: {},
if (!value) },
return value; mounted() {
value = JSON.parse(JSON.stringify(value)); setTimeout(() => {
if (!value.code || value.name === columnsPlaceholder[index]) { this.setValues();
value.code = ''; }, 0);
value.name = ''; },
} methods: {
return value; getPicker() {
}); if (this.picker == null) {
}, this.picker = this.selectComponent('.van-area__picker');
onChange(event) { }
const { index, picker, value } = event.detail; return this.picker;
this.code = value[index].code; },
this.setValues().then(() => { onCancel(event) {
this.$emit('change', { this.emit('cancel', event.detail);
picker, },
values: this.parseOutputValues(picker.getValues()), onConfirm(event) {
index const { index } = event.detail;
}); let { value } = event.detail;
}); value = this.parseOutputValues(value);
}, this.emit('confirm', { value, index });
getConfig(type) { },
const { areaList } = this.data; emit(type, detail) {
return (areaList && areaList[`${type}_list`]) || {}; detail.values = detail.value;
}, delete detail.value;
getList(type, code) { this.$emit(type, detail);
const { typeToColumnsPlaceholder } = this.data; },
let result = []; // parse output columns data
if (type !== 'province' && !code) { parseOutputValues(values) {
return result; const { columnsPlaceholder } = this.data;
} return values.map((value, index) => {
const list = this.getConfig(type); // save undefined value
result = Object.keys(list).map(code => ({ if (!value) return value;
code, value = JSON.parse(JSON.stringify(value));
name: list[code] if (!value.code || value.name === columnsPlaceholder[index]) {
})); value.code = '';
if (code) { value.name = '';
// 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' ? COLUMNSPLACEHOLDERCODE.slice(2, 4) : COLUMNSPLACEHOLDERCODE.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 county = this.getConfig('county');
let { code } = this;
if (!code) {
if (this.data.columnsPlaceholder.length) {
code = COLUMNSPLACEHOLDERCODE;
}
else if (Object.keys(county)[0]) {
code = Object.keys(county)[0];
}
else {
code = '';
}
}
const province = this.getList('province');
const city = this.getList('city', code.slice(0, 2));
const picker = this.getPicker();
if (!picker) {
return;
}
const stack = [];
stack.push(picker.setColumnValues(0, province, false));
stack.push(picker.setColumnValues(1, city, false));
if (city.length && code.slice(2, 4) === '00') {
[{ code }] = city;
}
stack.push(picker.setColumnValues(2, this.getList('county', code.slice(0, 4)), false));
return Promise.all(stack)
.catch(() => { })
.then(() => picker.setIndexes([
this.getIndex('province', code),
this.getIndex('city', code),
this.getIndex('county', code)
]))
.catch(() => { });
},
getValues() {
const picker = this.getPicker();
return picker ? 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();
} }
} return value;
});
},
onChange(event) {
const { index, picker, value } = event.detail;
this.code = value[index].code;
this.setValues().then(() => {
this.$emit('change', {
picker,
values: this.parseOutputValues(picker.getValues()),
index,
});
});
},
getConfig(type) {
const { areaList } = this.data;
return (areaList && areaList[`${type}_list`]) || {};
},
getList(type, code) {
const { typeToColumnsPlaceholder } = this.data;
let result = [];
if (type !== 'province' && !code) {
return result;
}
const list = this.getConfig(type);
result = Object.keys(list).map((code) => ({
code,
name: list[code],
}));
if (code) {
// 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'
? COLUMNSPLACEHOLDERCODE.slice(2, 4)
: COLUMNSPLACEHOLDERCODE.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 county = this.getConfig('county');
let { code } = this;
if (!code) {
if (this.data.columnsPlaceholder.length) {
code = COLUMNSPLACEHOLDERCODE;
} else if (Object.keys(county)[0]) {
code = Object.keys(county)[0];
} else {
code = '';
}
}
const province = this.getList('province');
const city = this.getList('city', code.slice(0, 2));
const picker = this.getPicker();
if (!picker) {
return;
}
const stack = [];
stack.push(picker.setColumnValues(0, province, false));
stack.push(picker.setColumnValues(1, city, false));
if (city.length && code.slice(2, 4) === '00') {
[{ code }] = city;
}
stack.push(
picker.setColumnValues(
2,
this.getList('county', code.slice(0, 4)),
false
)
);
return Promise.all(stack)
.catch(() => {})
.then(() =>
picker.setIndexes([
this.getIndex('province', code),
this.getIndex('city', code),
this.getIndex('county', code),
])
)
.catch(() => {});
},
getValues() {
const picker = this.getPicker();
return picker ? 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();
},
},
}); });

122
dist/button/index.js vendored
View File

@ -2,68 +2,68 @@ import { VantComponent } from '../common/component';
import { button } from '../mixins/button'; import { button } from '../mixins/button';
import { openType } from '../mixins/open-type'; import { openType } from '../mixins/open-type';
VantComponent({ VantComponent({
mixins: [button, openType], mixins: [button, openType],
classes: ['hover-class', 'loading-class'], classes: ['hover-class', 'loading-class'],
data: { data: {
baseStyle: '' baseStyle: '',
},
props: {
icon: String,
plain: Boolean,
block: Boolean,
round: Boolean,
square: Boolean,
loading: Boolean,
hairline: Boolean,
disabled: Boolean,
loadingText: String,
customStyle: String,
loadingType: {
type: String,
value: 'circular',
}, },
props: { type: {
icon: String, type: String,
plain: Boolean, value: 'default',
block: Boolean, },
round: Boolean, dataset: null,
square: Boolean, size: {
loading: Boolean, type: String,
hairline: Boolean, value: 'normal',
disabled: Boolean, },
loadingText: String, loadingSize: {
customStyle: String, type: String,
loadingType: { value: '20px',
type: String, },
value: 'circular' color: {
}, type: String,
type: { observer(color) {
type: String, let style = '';
value: 'default' if (color) {
}, style += `color: ${this.data.plain ? color : 'white'};`;
size: { if (!this.data.plain) {
type: String, // Use background instead of backgroundColor to make linear-gradient work
value: 'normal' style += `background: ${color};`;
}, }
loadingSize: { // hide border when color is linear-gradient
type: String, if (color.indexOf('gradient') !== -1) {
value: '20px' style += 'border: 0;';
}, } else {
color: { style += `border-color: ${color};`;
type: String, }
observer(color) {
let style = '';
if (color) {
style += `color: ${this.data.plain ? color : 'white'};`;
if (!this.data.plain) {
// Use background instead of backgroundColor to make linear-gradient work
style += `background: ${color};`;
}
// hide border when color is linear-gradient
if (color.indexOf('gradient') !== -1) {
style += 'border: 0;';
}
else {
style += `border-color: ${color};`;
}
}
if (style !== this.data.baseStyle) {
this.setData({ baseStyle: style });
}
}
} }
if (style !== this.data.baseStyle) {
this.setData({ baseStyle: style });
}
},
}, },
methods: { },
onClick() { methods: {
if (!this.data.loading) { onClick() {
this.$emit('click'); if (!this.data.loading) {
} this.$emit('click');
}, }
noop() { } },
} noop() {},
},
}); });

15
dist/button/index.wxml vendored
View File

@ -2,11 +2,12 @@
<button <button
id="{{ id }}" id="{{ id }}"
data-detail="{{ dataset }}"
class="custom-class {{ utils.bem('button', [type, size, { block, round, plain, square, loading, disabled, hairline, unclickable: disabled || loading }]) }} {{ hairline ? 'van-hairline--surround' : '' }}" class="custom-class {{ utils.bem('button', [type, size, { block, round, plain, square, loading, disabled, hairline, unclickable: disabled || loading }]) }} {{ hairline ? 'van-hairline--surround' : '' }}"
hover-class="van-button--active hover-class" hover-class="van-button--active hover-class"
lang="{{ lang }}" lang="{{ lang }}"
style="{{ baseStyle }} {{ customStyle }}" style="{{ baseStyle }} {{ customStyle }}"
open-type="{{ openType }}" open-type="{{ disabled ? '' : openType }}"
business-id="{{ businessId }}" business-id="{{ businessId }}"
session-from="{{ sessionFrom }}" session-from="{{ sessionFrom }}"
send-message-title="{{ sendMessageTitle }}" send-message-title="{{ sendMessageTitle }}"
@ -16,12 +17,12 @@
app-parameter="{{ appParameter }}" app-parameter="{{ appParameter }}"
aria-label="{{ ariaLabel }}" aria-label="{{ ariaLabel }}"
bindtap="{{ !disabled ? 'onClick' : 'noop' }}" bindtap="{{ !disabled ? 'onClick' : 'noop' }}"
bindgetuserinfo="{{ !disabled ? 'bindGetUserInfo' : 'noop' }}" bindgetuserinfo="bindGetUserInfo"
bindcontact="{{ !disabled ? 'bindContact' : 'noop' }}" bindcontact="bindContact"
bindgetphonenumber="{{ !disabled ? 'bindGetPhoneNumber' : 'noop' }}" bindgetphonenumber="bindGetPhoneNumber"
binderror="{{ !disabled ? 'bindError' : 'noop' }}" binderror="bindError"
bindlaunchapp="{{ !disabled ? 'bindLaunchApp' : 'noop' }}" bindlaunchapp="bindLaunchApp"
bindopensetting="{{ !disabled ? 'bindOpenSetting' : 'noop' }}" bindopensetting="bindOpenSetting"
> >
<block wx:if="{{ loading }}"> <block wx:if="{{ loading }}">
<van-loading <van-loading

24
dist/calendar/components/header/index.js vendored
View File

@ -1,16 +1,16 @@
import { VantComponent } from '../../../common/component'; import { VantComponent } from '../../../common/component';
VantComponent({ VantComponent({
props: { props: {
title: { title: {
type: String, type: String,
value: '日期选择' value: '日期选择',
},
subtitle: String,
showTitle: Boolean,
showSubtitle: Boolean
}, },
data: { subtitle: String,
weekdays: ['日', '一', '二', '三', '四', '五', '六'] showTitle: Boolean,
}, showSubtitle: Boolean,
methods: {} },
data: {
weekdays: ['日', '一', '二', '三', '四', '五', '六'],
},
methods: {},
}); });

293
dist/calendar/components/month/index.js vendored
View File

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

537
dist/calendar/index.js vendored
View File

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

10
dist/calendar/utils.d.ts vendored
View File

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

114
dist/calendar/utils.js vendored
View File

@ -1,78 +1,78 @@
export const ROW_HEIGHT = 64; export const ROW_HEIGHT = 64;
export function formatMonthTitle(date) { 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) { 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) { 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) { 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) { export function getPrevDay(date) {
return getDayByOffset(date, -1); return getDayByOffset(date, -1);
} }
export function getNextDay(date) { export function getNextDay(date) {
return getDayByOffset(date, 1); return getDayByOffset(date, 1);
} }
export function calcDateNum(date) { 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) { 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) { 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) { 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;
} }

88
dist/card/index.js vendored
View File

@ -1,49 +1,49 @@
import { link } from '../mixins/link'; import { link } from '../mixins/link';
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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: '¥'
}
}, },
methods: { centered: Boolean,
updatePrice() { lazyLoad: Boolean,
const { price } = this.data; thumbLink: String,
const priceArr = price.toString().split('.'); originPrice: String,
this.setData({ thumbMode: {
integerStr: priceArr[0], type: String,
decimalStr: priceArr[1] ? `.${priceArr[1]}` : '' value: 'aspectFit',
}); },
}, currency: {
onClickThumb() { type: String,
this.jumpLink('thumbLink'); 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');
},
},
}); });

14
dist/cell-group/index.js vendored
View File

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

2
dist/cell-group/index.json vendored
View File

@ -1,3 +1,3 @@
{ {
"component": true "component": true
} }

64
dist/cell/index.js vendored
View File

@ -1,37 +1,37 @@
import { link } from '../mixins/link'; import { link } from '../mixins/link';
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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,
}
}, },
methods: { },
onClick(event) { methods: {
this.$emit('click', event.detail); onClick(event) {
this.jumpLink(); this.$emit('click', event.detail);
} this.jumpLink();
} },
},
}); });

2
dist/cell/index.json vendored
View File

@ -3,4 +3,4 @@
"usingComponents": { "usingComponents": {
"van-icon": "../icon/index" "van-icon": "../icon/index"
} }
} }

60
dist/checkbox-group/index.js vendored
View File

@ -1,35 +1,35 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
field: true, field: true,
relation: { relation: {
name: 'checkbox', name: 'checkbox',
type: 'descendant', type: 'descendant',
current: 'checkbox-group', current: 'checkbox-group',
linked(target) { linked(target) {
this.updateChild(target); this.updateChild(target);
},
}, },
props: { },
max: Number, props: {
value: { max: Number,
type: Array, value: {
observer: 'updateChildren' type: Array,
}, observer: 'updateChildren',
disabled: {
type: Boolean,
observer: 'updateChildren'
}
}, },
methods: { disabled: {
updateChildren() { type: Boolean,
(this.children || []).forEach((child) => this.updateChild(child)); observer: 'updateChildren',
}, },
updateChild(child) { },
const { value, disabled } = this.data; methods: {
child.setData({ updateChildren() {
value: value.indexOf(child.data.name) !== -1, (this.children || []).forEach((child) => this.updateChild(child));
parentDisabled: disabled },
}); updateChild(child) {
} const { value, disabled } = this.data;
} child.setData({
value: value.indexOf(child.data.name) !== -1,
parentDisabled: disabled,
});
},
},
}); });

134
dist/checkbox/index.js vendored
View File

@ -1,76 +1,74 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
function emit(target, value) { function emit(target, value) {
target.$emit('input', value); target.$emit('input', value);
target.$emit('change', value); target.$emit('change', value);
} }
VantComponent({ VantComponent({
field: true, field: true,
relation: { relation: {
name: 'checkbox-group', name: 'checkbox-group',
type: 'ancestor', type: 'ancestor',
current: 'checkbox', current: 'checkbox',
},
classes: ['icon-class', 'label-class'],
props: {
value: Boolean,
disabled: Boolean,
useIconSlot: Boolean,
checkedColor: String,
labelPosition: String,
labelDisabled: Boolean,
shape: {
type: String,
value: 'round',
}, },
classes: ['icon-class', 'label-class'], iconSize: {
props: { type: null,
value: Boolean, value: 20,
disabled: Boolean, },
useIconSlot: Boolean, },
checkedColor: String, data: {
labelPosition: String, parentDisabled: false,
labelDisabled: Boolean, },
shape: { methods: {
type: String, emitChange(value) {
value: 'round' if (this.parent) {
}, this.setParentValue(this.parent, value);
iconSize: { } else {
type: null, emit(this, value);
value: 20 }
},
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) {
data: { parentValue.push(name);
parentDisabled: false emit(parent, parentValue);
},
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);
}
}
} }
} } else {
const index = parentValue.indexOf(name);
if (index !== -1) {
parentValue.splice(index, 1);
emit(parent, parentValue);
}
}
},
},
}); });

280
dist/circle/index.js vendored
View File

@ -2,154 +2,154 @@ import { VantComponent } from '../common/component';
import { isObj } from '../common/utils'; import { isObj } from '../common/utils';
import { BLUE, WHITE } from '../common/color'; import { BLUE, WHITE } from '../common/color';
function format(rate) { 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 PERIMETER = 2 * Math.PI;
const BEGIN_ANGLE = -Math.PI / 2; const BEGIN_ANGLE = -Math.PI / 2;
const STEP = 1; const STEP = 1;
VantComponent({ 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,
},
fill: String,
layerColor: {
type: String,
value: WHITE
},
color: {
type: [String, Object],
value: BLUE,
observer: 'setHoverColor'
},
type: {
type: String,
value: ''
},
strokeWidth: {
type: Number,
value: 4
},
clockwise: {
type: Boolean,
value: true
}
}, },
data: { value: {
hoverColor: BLUE type: Number,
value: 0,
observer: 'reRender',
}, },
methods: { speed: {
getContext() { type: Number,
if (!this.ctx) { value: 50,
this.ctx = wx.createCanvasContext('van-circle', this);
}
return this.ctx;
},
setHoverColor() {
const { color, size, type } = this.data;
const context = type ? this.getContext(type) : this.getContext();
let hoverColor = color;
if (isObj(color)) {
const LinearColor = context.createLinearGradient(size, 0, 0, 0);
Object.keys(color)
.sort((a, b) => parseFloat(a) - parseFloat(b))
.map(key => LinearColor.addColorStop(parseFloat(key) / 100, color[key]));
hoverColor = LinearColor;
}
this.setData({ hoverColor });
},
presetCanvas(context, strokeStyle, beginAngle, endAngle, fill) {
const { strokeWidth, lineCap, clockwise, size } = this.data;
const position = size / 2;
const radius = position - strokeWidth / 2;
context.setStrokeStyle(strokeStyle);
context.setLineWidth(strokeWidth);
context.setLineCap(lineCap);
context.beginPath();
context.arc(position, position, radius, beginAngle, endAngle, !clockwise);
context.stroke();
if (fill) {
context.setFillStyle(fill);
context.fill();
}
},
renderLayerCircle(context) {
const { layerColor, fill } = this.data;
this.presetCanvas(context, layerColor, 0, PERIMETER, fill);
},
renderHoverCircle(context, formatValue) {
const { clockwise, hoverColor } = this.data;
// 结束角度
const progress = PERIMETER * (formatValue / 100);
const endAngle = clockwise
? BEGIN_ANGLE + progress
: 3 * Math.PI - (BEGIN_ANGLE + progress);
this.presetCanvas(context, hoverColor, BEGIN_ANGLE, endAngle);
},
drawCircle(currentValue) {
const { size, type } = this.data;
const context = type ? this.getContext(type) : this.getContext();
context.clearRect(0, 0, size, size);
this.renderLayerCircle(context);
const formatValue = format(currentValue);
if (formatValue !== 0) {
this.renderHoverCircle(context, formatValue);
}
context.draw();
},
reRender() {
// tofector 动画暂时没有想到好的解决方案
const { value, speed } = this.data;
if (speed <= 0 || speed > 1000) {
this.drawCircle(value);
return;
}
this.clearInterval();
this.currentValue = this.currentValue || 0;
this.interval = setInterval(() => {
if (this.currentValue !== value) {
if (this.currentValue < value) {
this.currentValue += STEP;
}
else {
this.currentValue -= STEP;
}
this.drawCircle(this.currentValue);
}
else {
this.clearInterval();
}
}, 1000 / speed);
},
clearInterval() {
if (this.interval) {
clearInterval(this.interval);
this.interval = null;
}
}
}, },
created() { size: {
const { value } = this.data; type: Number,
this.currentValue = value; value: 100,
},
fill: String,
layerColor: {
type: String,
value: WHITE,
},
color: {
type: [String, Object],
value: BLUE,
observer: 'setHoverColor',
},
type: {
type: String,
value: '',
},
strokeWidth: {
type: Number,
value: 4,
},
clockwise: {
type: Boolean,
value: true,
},
},
data: {
hoverColor: BLUE,
},
methods: {
getContext() {
if (!this.ctx) {
this.ctx = wx.createCanvasContext('van-circle', this);
}
return this.ctx;
},
setHoverColor() {
const { color, size, type } = this.data;
const context = type ? this.getContext(type) : this.getContext();
let hoverColor = color;
if (isObj(color)) {
const LinearColor = context.createLinearGradient(size, 0, 0, 0);
Object.keys(color)
.sort((a, b) => parseFloat(a) - parseFloat(b))
.map((key) =>
LinearColor.addColorStop(parseFloat(key) / 100, color[key])
);
hoverColor = LinearColor;
}
this.setData({ hoverColor });
},
presetCanvas(context, strokeStyle, beginAngle, endAngle, fill) {
const { strokeWidth, lineCap, clockwise, size } = this.data;
const position = size / 2;
const radius = position - strokeWidth / 2;
context.setStrokeStyle(strokeStyle);
context.setLineWidth(strokeWidth);
context.setLineCap(lineCap);
context.beginPath();
context.arc(position, position, radius, beginAngle, endAngle, !clockwise);
context.stroke();
if (fill) {
context.setFillStyle(fill);
context.fill();
}
},
renderLayerCircle(context) {
const { layerColor, fill } = this.data;
this.presetCanvas(context, layerColor, 0, PERIMETER, fill);
},
renderHoverCircle(context, formatValue) {
const { clockwise, hoverColor } = this.data;
// 结束角度
const progress = PERIMETER * (formatValue / 100);
const endAngle = clockwise
? BEGIN_ANGLE + progress
: 3 * Math.PI - (BEGIN_ANGLE + progress);
this.presetCanvas(context, hoverColor, BEGIN_ANGLE, endAngle);
},
drawCircle(currentValue) {
const { size, type } = this.data;
const context = type ? this.getContext(type) : this.getContext();
context.clearRect(0, 0, size, size);
this.renderLayerCircle(context);
const formatValue = format(currentValue);
if (formatValue !== 0) {
this.renderHoverCircle(context, formatValue);
}
context.draw();
},
reRender() {
// tofector 动画暂时没有想到好的解决方案
const { value, speed } = this.data;
if (speed <= 0 || speed > 1000) {
this.drawCircle(value); this.drawCircle(value);
return;
}
this.clearInterval();
this.currentValue = this.currentValue || 0;
this.interval = setInterval(() => {
if (this.currentValue !== value) {
if (this.currentValue < value) {
this.currentValue += STEP;
} else {
this.currentValue -= STEP;
}
this.drawCircle(this.currentValue);
} else {
this.clearInterval();
}
}, 1000 / speed);
}, },
destroyed() { clearInterval() {
this.ctx = null; if (this.interval) {
this.clearInterval(); clearInterval(this.interval);
} this.interval = null;
}
},
},
created() {
const { value } = this.data;
this.currentValue = value;
this.drawCircle(value);
},
destroyed() {
this.ctx = null;
this.clearInterval();
},
}); });

42
dist/col/index.js vendored
View File

@ -1,24 +1,26 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
relation: { relation: {
name: 'row', name: 'row',
type: 'ancestor', type: 'ancestor',
current: 'col', current: 'col',
},
props: {
span: Number,
offset: Number,
},
data: {
viewStyle: '',
},
methods: {
setGutter(gutter) {
const padding = `${gutter / 2}px`;
const viewStyle = gutter
? `padding-left: ${padding}; padding-right: ${padding};`
: '';
if (viewStyle !== this.data.viewStyle) {
this.setData({ viewStyle });
}
}, },
props: { },
span: Number,
offset: Number
},
data: {
viewStyle: ''
},
methods: {
setGutter(gutter) {
const padding = `${gutter / 2}px`;
const viewStyle = gutter ? `padding-left: ${padding}; padding-right: ${padding};` : '';
if (viewStyle !== this.data.viewStyle) {
this.setData({ viewStyle });
}
}
}
}); });

170
dist/collapse-item/index.js vendored
View File

@ -1,94 +1,94 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
const nextTick = () => new Promise(resolve => setTimeout(resolve, 20)); const nextTick = () => new Promise((resolve) => setTimeout(resolve, 20));
VantComponent({ VantComponent({
classes: ['title-class', 'content-class'], classes: ['title-class', 'content-class'],
relation: { relation: {
name: 'collapse', name: 'collapse',
type: 'ancestor', type: 'ancestor',
current: 'collapse-item', current: 'collapse-item',
},
props: {
name: null,
title: null,
value: null,
icon: String,
label: String,
disabled: Boolean,
clickable: Boolean,
border: {
type: Boolean,
value: true,
}, },
props: { isLink: {
name: null, type: Boolean,
title: null, value: true,
value: null, },
icon: String, },
label: String, data: {
disabled: Boolean, contentHeight: 0,
clickable: Boolean, expanded: false,
border: { transition: false,
type: Boolean, },
value: true mounted() {
}, this.updateExpanded()
isLink: { .then(nextTick)
type: Boolean, .then(() => {
value: true const data = { transition: true };
if (this.data.expanded) {
data.contentHeight = 'auto';
} }
this.setData(data);
});
},
methods: {
updateExpanded() {
if (!this.parent) {
return Promise.resolve();
}
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);
const stack = [];
if (expanded !== this.data.expanded) {
stack.push(this.updateStyle(expanded));
}
stack.push(this.set({ index, expanded }));
return Promise.all(stack);
}, },
data: { updateStyle(expanded) {
contentHeight: 0, return this.getRect('.van-collapse-item__content')
expanded: false, .then((rect) => rect.height)
transition: false .then((height) => {
}, if (expanded) {
mounted() { return this.set({
this.updateExpanded() contentHeight: height ? `${height}px` : 'auto',
});
}
return this.set({ contentHeight: `${height}px` })
.then(nextTick) .then(nextTick)
.then(() => { .then(() => this.set({ contentHeight: 0 }));
const data = { transition: true };
if (this.data.expanded) {
data.contentHeight = 'auto';
}
this.setData(data);
}); });
}, },
methods: { onClick() {
updateExpanded() { if (this.data.disabled) {
if (!this.parent) { return;
return Promise.resolve(); }
} const { name, expanded } = this.data;
const { value, accordion } = this.parent.data; const index = this.parent.children.indexOf(this);
const { children = [] } = this.parent; const currentName = name == null ? index : name;
const { name } = this.data; this.parent.switch(currentName, !expanded);
const index = children.indexOf(this); },
const currentName = name == null ? index : name; onTransitionEnd() {
const expanded = accordion if (this.data.expanded) {
? value === currentName this.setData({
: (value || []).some((name) => name === currentName); contentHeight: 'auto',
const stack = []; });
if (expanded !== this.data.expanded) { }
stack.push(this.updateStyle(expanded)); },
} },
stack.push(this.set({ index, expanded }));
return Promise.all(stack);
},
updateStyle(expanded) {
return this.getRect('.van-collapse-item__content')
.then((rect) => rect.height)
.then((height) => {
if (expanded) {
return this.set({
contentHeight: height ? `${height}px` : 'auto'
});
}
return this.set({ contentHeight: `${height}px` })
.then(nextTick)
.then(() => this.set({ contentHeight: 0 }));
});
},
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);
},
onTransitionEnd() {
if (this.data.expanded) {
this.setData({
contentHeight: 'auto'
});
}
}
}
}); });

73
dist/collapse/index.js vendored
View File

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

176
dist/common/component.js vendored
View File

@ -1,101 +1,101 @@
import { basic } from '../mixins/basic'; import { basic } from '../mixins/basic';
const relationFunctions = { const relationFunctions = {
ancestor: { ancestor: {
linked(parent) { linked(parent) {
this.parent = parent; this.parent = parent;
},
unlinked() {
this.parent = null;
},
}, },
descendant: { unlinked() {
linked(child) { this.parent = null;
this.children = this.children || [];
this.children.push(child);
},
unlinked(child) {
this.children = (this.children || []).filter(it => it !== child);
},
}, },
},
descendant: {
linked(child) {
this.children = this.children || [];
this.children.push(child);
},
unlinked(child) {
this.children = (this.children || []).filter((it) => it !== child);
},
},
}; };
function mapKeys(source, target, map) { 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 makeRelation(options, vantOptions, relation) { function makeRelation(options, vantOptions, relation) {
const { type, name, linked, unlinked, linkChanged } = relation; const { type, name, linked, unlinked, linkChanged } = relation;
const { beforeCreate, destroyed } = vantOptions; const { beforeCreate, destroyed } = vantOptions;
if (type === 'descendant') { if (type === 'descendant') {
options.created = function () { options.created = function () {
beforeCreate && beforeCreate.bind(this)(); beforeCreate && beforeCreate.bind(this)();
this.children = this.children || []; this.children = this.children || [];
}; };
options.detached = function () { options.detached = function () {
this.children = []; this.children = [];
destroyed && destroyed.bind(this)(); destroyed && destroyed.bind(this)();
}; };
} }
options.relations = Object.assign(options.relations || {}, { options.relations = Object.assign(options.relations || {}, {
[`../${name}/index`]: { [`../${name}/index`]: {
type, type,
linked(node) { linked(node) {
relationFunctions[type].linked.bind(this)(node); relationFunctions[type].linked.bind(this)(node);
linked && linked.bind(this)(node); linked && linked.bind(this)(node);
}, },
linkChanged(node) { linkChanged(node) {
linkChanged && linkChanged.bind(this)(node); linkChanged && linkChanged.bind(this)(node);
}, },
unlinked(node) { unlinked(node) {
relationFunctions[type].unlinked.bind(this)(node); relationFunctions[type].unlinked.bind(this)(node);
unlinked && unlinked.bind(this)(node); unlinked && unlinked.bind(this)(node);
}, },
} },
}); });
} }
function VantComponent(vantOptions = {}) { 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',
relations: 'relations', relations: 'relations',
destroyed: 'detached', destroyed: 'detached',
classes: 'externalClasses' classes: 'externalClasses',
});
const { relation } = vantOptions;
if (relation) {
makeRelation(options, vantOptions, relation);
}
// add default externalClasses
options.externalClasses = options.externalClasses || [];
options.externalClasses.push('custom-class');
// add default behaviors
options.behaviors = options.behaviors || [];
options.behaviors.push(basic);
// map field to form-field behavior
if (vantOptions.field) {
options.behaviors.push('wx://form-field');
}
if (options.properties) {
Object.keys(options.properties).forEach((name) => {
if (Array.isArray(options.properties[name])) {
// miniprogram do not allow multi type
options.properties[name] = null;
}
}); });
const { relation } = vantOptions; }
if (relation) { // add default options
makeRelation(options, vantOptions, relation); options.options = {
} multipleSlots: true,
// add default externalClasses addGlobalClass: true,
options.externalClasses = options.externalClasses || []; };
options.externalClasses.push('custom-class'); Component(options);
// add default behaviors
options.behaviors = options.behaviors || [];
options.behaviors.push(basic);
// map field to form-field behavior
if (vantOptions.field) {
options.behaviors.push('wx://form-field');
}
if (options.properties) {
Object.keys(options.properties).forEach(name => {
if (Array.isArray(options.properties[name])) {
// miniprogram do not allow multi type
options.properties[name] = null;
}
});
}
// add default options
options.options = {
multipleSlots: true,
addGlobalClass: true
};
Component(options);
} }
export { VantComponent }; export { VantComponent };

2
dist/common/index.wxss vendored
View File

@ -1 +1 @@
.van-ellipsis{overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.van-multi-ellipsis--l2{-webkit-line-clamp:2}.van-multi-ellipsis--l2,.van-multi-ellipsis--l3{display:-webkit-box;overflow:hidden;text-overflow:ellipsis;-webkit-box-orient:vertical}.van-multi-ellipsis--l3{-webkit-line-clamp:3}.van-clearfix:after{display:table;clear:both;content:""}.van-hairline,.van-hairline--bottom,.van-hairline--left,.van-hairline--right,.van-hairline--surround,.van-hairline--top,.van-hairline--top-bottom{position:relative}.van-hairline--bottom:after,.van-hairline--left:after,.van-hairline--right:after,.van-hairline--surround:after,.van-hairline--top-bottom:after,.van-hairline--top:after,.van-hairline:after{position:absolute;box-sizing:border-box;-webkit-transform-origin:center;transform-origin:center;content:" ";pointer-events:none;top:-50%;right:-50%;bottom:-50%;left:-50%;border:0 solid #eee;-webkit-transform:scale(.5);transform:scale(.5)}.van-hairline--top:after{border-top-width:1px}.van-hairline--left:after{border-left-width:1px}.van-hairline--right:after{border-right-width:1px}.van-hairline--bottom:after{border-bottom-width:1px}.van-hairline--top-bottom:after{border-width:1px 0}.van-hairline--surround:after{border-width:1px} page{font-family:-apple-system,BlinkMacSystemFont,Helvetica Neue,Helvetica,Segoe UI,Arial,Roboto,PingFang SC,Hiragino Sans GB,Microsoft Yahei,sans-serif}.van-ellipsis{overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.van-multi-ellipsis--l2{-webkit-line-clamp:2}.van-multi-ellipsis--l2,.van-multi-ellipsis--l3{display:-webkit-box;overflow:hidden;text-overflow:ellipsis;-webkit-box-orient:vertical}.van-multi-ellipsis--l3{-webkit-line-clamp:3}.van-clearfix:after{display:table;clear:both;content:""}.van-hairline,.van-hairline--bottom,.van-hairline--left,.van-hairline--right,.van-hairline--surround,.van-hairline--top,.van-hairline--top-bottom{position:relative}.van-hairline--bottom:after,.van-hairline--left:after,.van-hairline--right:after,.van-hairline--surround:after,.van-hairline--top-bottom:after,.van-hairline--top:after,.van-hairline:after{position:absolute;box-sizing:border-box;-webkit-transform-origin:center;transform-origin:center;content:" ";pointer-events:none;top:-50%;right:-50%;bottom:-50%;left:-50%;border:0 solid #eee;-webkit-transform:scale(.5);transform:scale(.5)}.van-hairline--top:after{border-top-width:1px}.van-hairline--left:after{border-left-width:1px}.van-hairline--right:after{border-right-width:1px}.van-hairline--bottom:after{border-bottom-width:1px}.van-hairline--top-bottom:after{border-width:1px 0}.van-hairline--surround:after{border-width:1px}

1
dist/common/style/normalize.wxss vendored Normal file
View File

@ -0,0 +1 @@
page{font-family:-apple-system,BlinkMacSystemFont,Helvetica Neue,Helvetica,Segoe UI,Arial,Roboto,PingFang SC,Hiragino Sans GB,Microsoft Yahei,sans-serif}

2
dist/common/utils.d.ts vendored
View File

@ -4,5 +4,5 @@ export declare function isObj(x: any): boolean;
export declare function isNumber(value: any): boolean; export declare function isNumber(value: any): boolean;
export declare function range(num: number, min: number, max: number): number; export declare function range(num: number, min: number, max: number): number;
export declare function nextTick(fn: Function): void; export declare function nextTick(fn: Function): void;
export declare function getSystemInfoSync(): WechatMiniprogram.GetSystemInfoSuccessCallbackResult; export declare function getSystemInfoSync(): WechatMiniprogram.GetSystemInfoSyncResult;
export declare function addUnit(value?: string | number): string | undefined; export declare function addUnit(value?: string | number): string | undefined;

1
dist/common/version.d.ts vendored Normal file
View File

@ -0,0 +1 @@
export declare function canIUseModel(): boolean;

27
dist/common/version.js vendored Normal file
View File

@ -0,0 +1,27 @@
import { getSystemInfoSync } from './utils';
function compareVersion(v1, v2) {
v1 = v1.split('.');
v2 = v2.split('.');
const len = Math.max(v1.length, v2.length);
while (v1.length < len) {
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) {
return -1;
}
}
return 0;
}
export function canIUseModel() {
const system = getSystemInfoSync();
return compareVersion(system.SDKVersion, '2.9.3') >= 0;
}

181
dist/count-down/index.js vendored
View File

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

86
dist/count-down/utils.js vendored
View File

@ -1,57 +1,53 @@
function padZero(num, targetLength = 2) { 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 SECOND = 1000;
const MINUTE = 60 * SECOND; const MINUTE = 60 * SECOND;
const HOUR = 60 * MINUTE; const HOUR = 60 * MINUTE;
const DAY = 24 * HOUR; const DAY = 24 * HOUR;
export function parseTimeData(time) { 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) { 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 {
else { format = format.replace('DD', padZero(days));
format = format.replace('DD', padZero(days)); }
} if (format.indexOf('HH') === -1) {
if (format.indexOf('HH') === -1) { minutes += hours * 60;
minutes += hours * 60; } else {
} format = format.replace('HH', padZero(hours));
else { }
format = format.replace('HH', padZero(hours)); if (format.indexOf('mm') === -1) {
} seconds += minutes * 60;
if (format.indexOf('mm') === -1) { } else {
seconds += minutes * 60; format = format.replace('mm', padZero(minutes));
} }
else { if (format.indexOf('ss') === -1) {
format = format.replace('mm', padZero(minutes)); milliseconds += seconds * 1000;
} } else {
if (format.indexOf('ss') === -1) { format = format.replace('ss', padZero(seconds));
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) { export function isSameSecond(time1, time2) {
return Math.floor(time1 / 1000) === Math.floor(time2 / 1000); return Math.floor(time1 / 1000) === Math.floor(time2 / 1000);
} }

570
dist/datetime-picker/index.js vendored
View File

@ -3,295 +3,315 @@ import { isDef } from '../common/utils';
import { pickerProps } from '../picker/shared'; import { pickerProps } from '../picker/shared';
const currentYear = new Date().getFullYear(); const currentYear = new Date().getFullYear();
function isValidDate(date) { function isValidDate(date) {
return isDef(date) && !isNaN(new Date(date).getTime()); return isDef(date) && !isNaN(new Date(date).getTime());
} }
function range(num, min, max) { function range(num, min, max) {
return Math.min(Math.max(num, min), max); return Math.min(Math.max(num, min), max);
} }
function padZero(val) { function padZero(val) {
return `00${val}`.slice(-2); return `00${val}`.slice(-2);
} }
function times(n, iteratee) { 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) { function getTrueValue(formattedValue) {
if (!formattedValue) if (!formattedValue) return;
return; 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) { function getMonthEndDay(year, month) {
return 32 - new Date(year, month - 1, 32).getDate(); return 32 - new Date(year, month - 1, 32).getDate();
} }
const defaultFormatter = (_, value) => value; const defaultFormatter = (_, value) => value;
VantComponent({ VantComponent({
classes: ['active-class', 'toolbar-class', 'column-class'], classes: ['active-class', 'toolbar-class', 'column-class'],
props: Object.assign(Object.assign({}, pickerProps), { value: { props: Object.assign(Object.assign({}, pickerProps), {
type: null, value: {
observer: 'updateValue' type: null,
}, filter: null, type: { observer: 'updateValue',
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: []
}, },
methods: { filter: null,
updateValue() { type: {
const { data } = this; type: String,
const val = this.correctValue(this.data.value); value: 'datetime',
const isEqual = val === data.innerValue; observer: 'updateValue',
if (!isEqual) {
this.updateColumnValue(val).then(() => {
this.$emit('input', val);
});
}
else {
this.updateColumns();
}
},
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 => {
let value = range[0] + index;
value = type === 'year' ? `${value}` : padZero(value);
return 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();
if (data.type === 'time') {
const indexes = picker.getIndexes();
value = `${+data.columns[0].values[indexes[0]]}:${+data.columns[1].values[indexes[1]]}`;
}
else {
const values = picker.getValues();
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, formatter = defaultFormatter } = this.data;
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() { showToolbar: {
const innerValue = this.correctValue(this.data.value); type: Boolean,
this.updateColumnValue(innerValue).then(() => { value: true,
this.$emit('input', innerValue); },
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(this.data.value);
const isEqual = val === data.innerValue;
if (!isEqual) {
this.updateColumnValue(val).then(() => {
this.$emit('input', val);
}); });
} } else {
this.updateColumns();
}
},
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) => {
let value = range[0] + index;
value = type === 'year' ? `${value}` : padZero(value);
return 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();
if (data.type === 'time') {
const indexes = picker.getIndexes();
value = `${+data.columns[0].values[indexes[0]]}:${+data.columns[1]
.values[indexes[1]]}`;
} else {
const values = picker.getValues();
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, formatter = defaultFormatter } = this.data;
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);
});
},
}); });

98
dist/dialog/dialog.js vendored
View File

@ -1,63 +1,67 @@
let queue = []; let queue = [];
function getContext() { function getContext() {
const pages = getCurrentPages(); const pages = getCurrentPages();
return pages[pages.length - 1]; return pages[pages.length - 1];
} }
const Dialog = options => { const Dialog = (options) => {
options = Object.assign(Object.assign({}, Dialog.currentOptions), options); options = Object.assign(Object.assign({}, Dialog.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(Object.assign({ onCancel: reject, onConfirm: resolve }, options)); dialog.setData(
queue.push(dialog); Object.assign({ onCancel: reject, onConfirm: resolve }, options)
} );
else { queue.push(dialog);
console.warn('未找到 van-dialog 节点，请确认 selector 及 context 是否正确'); } else {
} console.warn(
}); '未找到 van-dialog 节点，请确认 selector 及 context 是否正确'
);
}
});
}; };
Dialog.defaultOptions = { Dialog.defaultOptions = {
show: true, show: true,
title: '', title: '',
width: null, width: null,
message: '', message: '',
zIndex: 100, zIndex: 100,
overlay: true, overlay: true,
selector: '#van-dialog', selector: '#van-dialog',
className: '', className: '',
asyncClose: false, asyncClose: false,
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: '',
}; };
Dialog.alert = Dialog; Dialog.alert = Dialog;
Dialog.confirm = options => Dialog(Object.assign({ showCancelButton: true }, options)); Dialog.confirm = (options) =>
Dialog(Object.assign({ showCancelButton: true }, options));
Dialog.close = () => { Dialog.close = () => {
queue.forEach(dialog => { queue.forEach((dialog) => {
dialog.close(); dialog.close();
}); });
queue = []; queue = [];
}; };
Dialog.stopLoading = () => { Dialog.stopLoading = () => {
queue.forEach(dialog => { queue.forEach((dialog) => {
dialog.stopLoading(); dialog.stopLoading();
}); });
}; };
Dialog.setDefaultOptions = options => { Dialog.setDefaultOptions = (options) => {
Object.assign(Dialog.currentOptions, options); Object.assign(Dialog.currentOptions, options);
}; };
Dialog.resetDefaultOptions = () => { Dialog.resetDefaultOptions = () => {
Dialog.currentOptions = Object.assign({}, Dialog.defaultOptions); Dialog.currentOptions = Object.assign({}, Dialog.defaultOptions);
}; };
Dialog.resetDefaultOptions(); Dialog.resetDefaultOptions();
export default Dialog; export default Dialog;

204
dist/dialog/index.js vendored
View File

@ -3,108 +3,110 @@ import { button } from '../mixins/button';
import { openType } from '../mixins/open-type'; import { openType } from '../mixins/open-type';
import { GRAY, BLUE } from '../common/color'; import { GRAY, BLUE } from '../common/color';
VantComponent({ VantComponent({
mixins: [button, openType], mixins: [button, openType],
props: { props: {
show: { show: {
type: Boolean, type: Boolean,
observer(show) { observer(show) {
!show && this.stopLoading(); !show && this.stopLoading();
} },
},
title: String,
message: String,
useSlot: Boolean,
className: String,
customStyle: String,
asyncClose: Boolean,
messageAlign: String,
overlayStyle: String,
useTitleSlot: Boolean,
showCancelButton: Boolean,
closeOnClickOverlay: Boolean,
confirmButtonOpenType: String,
width: null,
zIndex: {
type: Number,
value: 2000
},
confirmButtonText: {
type: String,
value: '确认'
},
cancelButtonText: {
type: String,
value: '取消'
},
confirmButtonColor: {
type: String,
value: BLUE
},
cancelButtonColor: {
type: String,
value: GRAY
},
showConfirmButton: {
type: Boolean,
value: true
},
overlay: {
type: Boolean,
value: true
},
transition: {
type: String,
value: 'scale'
}
}, },
data: { title: String,
message: String,
useSlot: Boolean,
className: String,
customStyle: String,
asyncClose: Boolean,
messageAlign: String,
overlayStyle: String,
useTitleSlot: Boolean,
showCancelButton: Boolean,
closeOnClickOverlay: Boolean,
confirmButtonOpenType: String,
width: null,
zIndex: {
type: Number,
value: 2000,
},
confirmButtonText: {
type: String,
value: '确认',
},
cancelButtonText: {
type: String,
value: '取消',
},
confirmButtonColor: {
type: String,
value: BLUE,
},
cancelButtonColor: {
type: String,
value: GRAY,
},
showConfirmButton: {
type: Boolean,
value: true,
},
overlay: {
type: Boolean,
value: true,
},
transition: {
type: String,
value: 'scale',
},
},
data: {
loading: {
confirm: false,
cancel: false,
},
},
methods: {
onConfirm() {
this.handleAction('confirm');
},
onCancel() {
this.handleAction('cancel');
},
onClickOverlay() {
this.onClose('overlay');
},
handleAction(action) {
if (this.data.asyncClose) {
this.setData({
[`loading.${action}`]: true,
});
}
this.onClose(action);
},
close() {
this.setData({
show: false,
});
},
stopLoading() {
this.setData({
loading: { loading: {
confirm: false, confirm: false,
cancel: false cancel: false,
} },
});
}, },
methods: { onClose(action) {
onConfirm() { if (!this.data.asyncClose) {
this.handleAction('confirm'); this.close();
}, }
onCancel() { this.$emit('close', action);
this.handleAction('cancel'); // 把 dialog 实例传递出去，可以通过 stopLoading() 在外部关闭按钮的 loading
}, this.$emit(action, { dialog: this });
onClickOverlay() { const callback = this.data[
this.onClose('overlay'); action === 'confirm' ? 'onConfirm' : 'onCancel'
}, ];
handleAction(action) { if (callback) {
if (this.data.asyncClose) { callback(this);
this.setData({ }
[`loading.${action}`]: true },
}); },
}
this.onClose(action);
},
close() {
this.setData({
show: false
});
},
stopLoading() {
this.setData({
loading: {
confirm: false,
cancel: false
}
});
},
onClose(action) {
if (!this.data.asyncClose) {
this.close();
}
this.$emit('close', action);
// 把 dialog 实例传递出去，可以通过 stopLoading() 在外部关闭按钮的 loading
this.$emit(action, { dialog: this });
const callback = this.data[action === 'confirm' ? 'onConfirm' : 'onCancel'];
if (callback) {
callback(this);
}
}
}
}); });

2
dist/dialog/index.wxml vendored
View File

@ -16,7 +16,7 @@
class="van-dialog__header {{ message || useSlot ? '' : 'van-dialog--isolated' }}" class="van-dialog__header {{ message || useSlot ? '' : 'van-dialog--isolated' }}"
> >
<slot wx:if="{{ useTitleSlot }}" name="title" /> <slot wx:if="{{ useTitleSlot }}" name="title" />
<block wx:elif="{{ title }}"> {{ title }}</block> <block wx:elif="{{ title }}">{{ title }}</block>
</view> </view>
<slot wx:if="{{ useSlot }}" /> <slot wx:if="{{ useSlot }}" />

60
dist/divider/index.js vendored
View File

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

2
dist/divider/index.json vendored
View File

@ -1,4 +1,4 @@
{ {
"component": true, "component": true,
"usingComponents": {} "usingComponents": {}
} }

201
dist/dropdown-item/index.js vendored
View File

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

218
dist/dropdown-menu/index.js vendored
View File

@ -2,118 +2,118 @@ import { VantComponent } from '../common/component';
import { addUnit } from '../common/utils'; import { addUnit } from '../common/utils';
let ARRAY = []; let ARRAY = [];
VantComponent({ VantComponent({
field: true, field: true,
relation: { relation: {
name: 'dropdown-item', name: 'dropdown-item',
type: 'descendant', type: 'descendant',
current: 'dropdown-menu', current: 'dropdown-menu',
linked() { linked() {
this.updateItemListData(); this.updateItemListData();
}, },
unlinked() { unlinked() {
this.updateItemListData(); this.updateItemListData();
},
},
props: {
activeColor: {
type: String,
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,
},
},
data: {
itemListData: [],
},
beforeCreate() {
const { windowHeight } = wx.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 });
} }
});
}, },
props: { close() {
activeColor: { this.children.forEach((child) => {
type: String, child.toggle(false, { immediate: true });
observer: 'updateChildrenData' });
}, },
overlay: { getChildWrapperStyle() {
type: Boolean, const { zIndex, direction } = this.data;
value: true, return this.getRect('.van-dropdown-menu').then((rect) => {
observer: 'updateChildrenData' const { top = 0, bottom = 0 } = rect;
}, const offset = direction === 'down' ? bottom : this.windowHeight - top;
zIndex: { let wrapperStyle = `z-index: ${zIndex};`;
type: Number, if (direction === 'down') {
value: 10 wrapperStyle += `top: ${addUnit(offset)};`;
}, } else {
duration: { wrapperStyle += `bottom: ${addUnit(offset)};`;
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
} }
return wrapperStyle;
});
}, },
data: { onTitleTap(event) {
itemListData: [] 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);
}
}, },
beforeCreate() { },
const { windowHeight } = wx.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 this.getRect('.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);
}
}
}
}); });

2
dist/dropdown-menu/index.json vendored
View File

@ -1,3 +1,3 @@
{ {
"component": true "component": true
} }

208
dist/field/index.js vendored
View File

@ -1,93 +1,125 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { commonProps, inputProps, textareaProps } from './props'; import { commonProps, inputProps, textareaProps } from './props';
import { canIUseModel } from '../common/version';
VantComponent({ VantComponent({
field: true, field: true,
classes: ['input-class', 'right-icon-class'], classes: ['input-class', 'right-icon-class'],
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: [Boolean, Object], readonly: { props: Object.assign(
type: Boolean, Object.assign(
observer: 'setShowClear' Object.assign(Object.assign({}, commonProps), inputProps),
}, required: Boolean, iconClass: String, clearable: { textareaProps
type: Boolean, ),
observer: 'setShowClear' {
}, clickable: Boolean, inputAlign: String, customStyle: String, errorMessage: String, arrowDirection: String, showWordLimit: Boolean, errorMessageAlign: String, border: { size: String,
type: Boolean, icon: String,
value: true label: String,
}, titleWidth: { error: Boolean,
type: String, center: Boolean,
value: '90px' isLink: Boolean,
} }), leftIcon: String,
data: { rightIcon: String,
focused: false, autosize: [Boolean, Object],
innerValue: '', readonly: {
showClear: false type: Boolean,
}, observer: 'setShowClear',
created() { },
this.value = this.data.value; required: Boolean,
this.setData({ innerValue: this.value }); iconClass: String,
}, clearable: {
methods: { type: Boolean,
onInput(event) { observer: 'setShowClear',
const { value = '' } = event.detail || {}; },
this.value = value; clickable: Boolean,
this.setShowClear(); inputAlign: String,
this.emitChange(); customStyle: String,
}, errorMessage: String,
onFocus(event) { arrowDirection: String,
this.focused = true; showWordLimit: Boolean,
this.setShowClear(); errorMessageAlign: String,
this.$emit('focus', event.detail); border: {
}, type: Boolean,
onBlur(event) { value: true,
this.focused = false; },
this.setShowClear(); titleWidth: {
this.$emit('blur', event.detail); type: String,
}, value: '90px',
onClickIcon() { },
this.$emit('click-icon');
},
onClear() {
this.setData({ innerValue: '' });
this.value = '';
this.setShowClear();
wx.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 });
wx.nextTick(() => {
this.$emit('input', this.value);
this.$emit('change', this.value);
});
},
setShowClear() {
const { clearable, readonly } = this.data;
const { focused, value } = this;
this.setData({
showClear: !!clearable && !!focused && !!value && !readonly
});
},
noop() { }
} }
),
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) {
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');
},
onClear() {
this.setData({ innerValue: '' });
this.value = '';
this.setShowClear();
wx.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() {
if (canIUseModel()) {
this.setData({ value: this.value });
}
wx.nextTick(() => {
this.$emit('input', this.value);
this.$emit('change', this.value);
});
},
setShowClear() {
const { clearable, readonly } = this.data;
const { focused, value } = this;
this.setData({
showClear: !!clearable && !!focused && !!value && !readonly,
});
},
noop() {},
},
}); });

2
dist/field/index.json vendored
View File

@ -4,4 +4,4 @@
"van-cell": "../cell/index", "van-cell": "../cell/index",
"van-icon": "../icon/index" "van-icon": "../icon/index"
} }
} }

2
dist/field/index.wxml vendored
View File

@ -98,7 +98,7 @@
<view wx:if="{{ showWordLimit && maxlength }}" class="van-field__word-limit"> <view wx:if="{{ showWordLimit && maxlength }}" class="van-field__word-limit">
<view class="{{ utils.bem('field__word-num', { full: value.length >= maxlength }) }}">{{ value.length }}</view>/{{ maxlength }} <view class="{{ utils.bem('field__word-num', { full: value.length >= maxlength }) }}">{{ value.length }}</view>/{{ maxlength }}
</view> </view>
<view wx:if="{{ errorMessage }}" class="van-field__error-message {{ utils.bem('field__error', [errorMessageAlign, { disabled, error }]) }}"> <view wx:if="{{ errorMessage }}" class="{{ utils.bem('field__error-message', [errorMessageAlign, { disabled, error }]) }}">
{{ errorMessage }} {{ errorMessage }}
</view> </view>
</van-cell> </van-cell>

112
dist/field/props.js vendored
View File

@ -1,63 +1,63 @@
export const commonProps = { 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, },
placeholderStyle: String, placeholder: String,
placeholderClass: String, placeholderStyle: String,
disabled: Boolean, placeholderClass: String,
maxlength: { disabled: Boolean,
type: Number, maxlength: {
value: -1 type: Number,
}, value: -1,
cursorSpacing: { },
type: Number, cursorSpacing: {
value: 50 type: Number,
}, value: 50,
autoFocus: Boolean, },
focus: Boolean, autoFocus: Boolean,
cursor: { focus: Boolean,
type: Number, cursor: {
value: -1 type: Number,
}, value: -1,
selectionStart: { },
type: Number, selectionStart: {
value: -1 type: Number,
}, value: -1,
selectionEnd: { },
type: Number, selectionEnd: {
value: -1 type: Number,
}, value: -1,
adjustPosition: { },
type: Boolean, adjustPosition: {
value: true type: Boolean,
}, value: true,
holdKeyboard: Boolean },
holdKeyboard: Boolean,
}; };
export const inputProps = { 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 = { 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,
}, },
}; };

64
dist/goods-action-button/index.js vendored
View File

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

30
dist/goods-action-icon/index.js vendored
View File

@ -3,20 +3,20 @@ import { link } from '../mixins/link';
import { button } from '../mixins/button'; import { button } from '../mixins/button';
import { openType } from '../mixins/open-type'; import { openType } from '../mixins/open-type';
VantComponent({ VantComponent({
classes: ['icon-class', 'text-class'], classes: ['icon-class', 'text-class'],
mixins: [link, button, openType], mixins: [link, button, openType],
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: {
onClick(event) {
this.$emit('click', event.detail);
this.jumpLink();
}, },
methods: { },
onClick(event) {
this.$emit('click', event.detail);
this.jumpLink();
}
}
}); });

20
dist/goods-action/index.js vendored
View File

@ -1,14 +1,14 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
relation: { relation: {
type: 'descendant', type: 'descendant',
name: 'goods-action-button', name: 'goods-action-button',
current: 'goods-action', current: 'goods-action',
},
props: {
safeAreaInsetBottom: {
type: Boolean,
value: true,
}, },
props: { },
safeAreaInsetBottom: {
type: Boolean,
value: true
}
}
}); });

122
dist/grid-item/index.js vendored
View File

@ -2,69 +2,69 @@ import { link } from '../mixins/link';
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { addUnit } from '../common/utils'; import { addUnit } from '../common/utils';
VantComponent({ VantComponent({
relation: { relation: {
name: 'grid', name: 'grid',
type: 'ancestor', type: 'ancestor',
current: 'grid-item', current: 'grid-item',
}, },
classes: ['content-class', 'icon-class', 'text-class'], classes: ['content-class', 'icon-class', 'text-class'],
mixins: [link], mixins: [link],
props: { props: {
icon: String, icon: String,
dot: Boolean, dot: Boolean,
info: null, info: null,
text: String, text: String,
useSlot: Boolean useSlot: Boolean,
}, },
data: { data: {
viewStyle: '', viewStyle: '',
}, },
mounted() { mounted() {
this.updateStyle(); this.updateStyle();
}, },
methods: { methods: {
updateStyle() { updateStyle() {
if (!this.parent) { if (!this.parent) {
return; return;
} }
const { data, children } = this.parent; const { data, children } = this.parent;
const { columnNum, border, square, gutter, clickable, center } = data; const { columnNum, border, square, gutter, clickable, center } = data;
const width = `${100 / columnNum}%`; const width = `${100 / columnNum}%`;
const styleWrapper = []; const styleWrapper = [];
styleWrapper.push(`width: ${width}`); styleWrapper.push(`width: ${width}`);
if (square) { if (square) {
styleWrapper.push(`padding-top: ${width}`); styleWrapper.push(`padding-top: ${width}`);
} }
if (gutter) { if (gutter) {
const gutterValue = addUnit(gutter); const gutterValue = addUnit(gutter);
styleWrapper.push(`padding-right: ${gutterValue}`); styleWrapper.push(`padding-right: ${gutterValue}`);
const index = children.indexOf(this); const index = children.indexOf(this);
if (index >= columnNum) { if (index >= columnNum) {
styleWrapper.push(`margin-top: ${gutterValue}`); styleWrapper.push(`margin-top: ${gutterValue}`);
} }
} }
let contentStyle = ''; let contentStyle = '';
if (square && gutter) { if (square && gutter) {
const gutterValue = addUnit(gutter); const gutterValue = addUnit(gutter);
contentStyle = ` contentStyle = `
right: ${gutterValue}; right: ${gutterValue};
bottom: ${gutterValue}; bottom: ${gutterValue};
height: auto; height: auto;
`; `;
} }
this.setData({ this.setData({
viewStyle: styleWrapper.join('; '), viewStyle: styleWrapper.join('; '),
contentStyle, contentStyle,
center, center,
border, border,
square, square,
gutter, gutter,
clickable clickable,
}); });
}, },
onClick() { onClick() {
this.$emit('click'); this.$emit('click');
this.jumpLink(); this.jumpLink();
} },
} },
}); });

96
dist/grid/index.js vendored
View File

@ -1,57 +1,57 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { addUnit } from '../common/utils'; import { addUnit } from '../common/utils';
VantComponent({ VantComponent({
relation: { relation: {
name: 'grid-item', name: 'grid-item',
type: 'descendant', type: 'descendant',
current: 'grid', current: 'grid',
},
props: {
square: {
type: Boolean,
observer: 'updateChildren',
}, },
props: { gutter: {
square: { type: [Number, String],
type: Boolean, value: 0,
observer: 'updateChildren' observer: 'updateChildren',
},
gutter: {
type: [Number, String],
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'
}
}, },
data: { clickable: {
viewStyle: '', type: Boolean,
observer: 'updateChildren',
}, },
created() { columnNum: {
const { gutter } = this.data; type: Number,
if (gutter) { value: 4,
this.setData({ observer: 'updateChildren',
viewStyle: `padding-left: ${addUnit(gutter)}`
});
}
}, },
methods: { center: {
updateChildren() { type: Boolean,
this.children.forEach((child) => { value: true,
child.updateStyle(); observer: 'updateChildren',
}); },
} border: {
type: Boolean,
value: true,
observer: 'updateChildren',
},
},
data: {
viewStyle: '',
},
created() {
const { gutter } = this.data;
if (gutter) {
this.setData({
viewStyle: `padding-left: ${addUnit(gutter)}`,
});
} }
},
methods: {
updateChildren() {
this.children.forEach((child) => {
child.updateStyle();
});
},
},
}); });

46
dist/icon/index.js vendored
View File

@ -1,27 +1,27 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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: {
type: String,
observer(val) {
this.setData({
isImageName: val.indexOf('/') !== -1
});
}
}
}, },
methods: { name: {
onClick() { type: String,
this.$emit('click'); observer(val) {
} this.setData({
} isImageName: val.indexOf('/') !== -1,
});
},
},
},
methods: {
onClick() {
this.$emit('click');
},
},
}); });

180
dist/image/index.js vendored
View File

@ -3,99 +3,99 @@ import { VantComponent } from '../common/component';
import { button } from '../mixins/button'; import { button } from '../mixins/button';
import { openType } from '../mixins/open-type'; import { openType } from '../mixins/open-type';
const FIT_MODE_MAP = { const FIT_MODE_MAP = {
none: 'center', none: 'center',
fill: 'scaleToFill', fill: 'scaleToFill',
cover: 'aspectFill', cover: 'aspectFill',
contain: 'aspectFit', contain: 'aspectFit',
widthFix: 'widthFix', widthFix: 'widthFix',
heightFix: 'heightFix' heightFix: 'heightFix',
}; };
VantComponent({ VantComponent({
mixins: [button, openType], mixins: [button, openType],
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: {
type: null,
observer: 'setStyle'
},
height: {
type: null,
observer: 'setStyle'
},
radius: null,
lazyLoad: Boolean,
useErrorSlot: Boolean,
useLoadingSlot: Boolean,
showMenuByLongpress: Boolean,
fit: {
type: String,
value: 'fill',
observer: 'setMode'
},
showError: {
type: Boolean,
value: true
},
showLoading: {
type: Boolean,
value: true
}
}, },
data: { round: Boolean,
error: false, width: {
loading: true, type: null,
viewStyle: '', observer: 'setStyle',
}, },
mounted() { height: {
this.setMode(); type: null,
this.setStyle(); observer: 'setStyle',
}, },
methods: { radius: null,
setMode() { lazyLoad: Boolean,
this.setData({ useErrorSlot: Boolean,
mode: FIT_MODE_MAP[this.data.fit], useLoadingSlot: Boolean,
}); showMenuByLongpress: Boolean,
}, fit: {
setStyle() { type: String,
const { width, height, radius } = this.data; value: 'fill',
let style = ''; observer: 'setMode',
if (isDef(width)) { },
style += `width: ${addUnit(width)};`; showError: {
} type: Boolean,
if (isDef(height)) { value: true,
style += `height: ${addUnit(height)};`; },
} showLoading: {
if (isDef(radius)) { type: Boolean,
style += 'overflow: hidden;'; value: true,
style += `border-radius: ${addUnit(radius)};`; },
} },
this.setData({ viewStyle: style }); data: {
}, error: false,
onLoad(event) { loading: true,
this.setData({ viewStyle: '',
loading: false },
}); mounted() {
this.$emit('load', event.detail); this.setMode();
}, this.setStyle();
onError(event) { },
this.setData({ methods: {
loading: false, setMode() {
error: true this.setData({
}); mode: FIT_MODE_MAP[this.data.fit],
this.$emit('error', event.detail); });
}, },
onClick(event) { setStyle() {
this.$emit('click', event.detail); const { width, height, radius } = this.data;
} let style = '';
} if (isDef(width)) {
style += `width: ${addUnit(width)};`;
}
if (isDef(height)) {
style += `height: ${addUnit(height)};`;
}
if (isDef(radius)) {
style += 'overflow: hidden;';
style += `border-radius: ${addUnit(radius)};`;
}
this.setData({ viewStyle: style });
},
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);
},
},
}); });

50
dist/index-anchor/index.js vendored
View File

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

444
dist/index-bar/index.js vendored
View File

@ -2,249 +2,249 @@ import { VantComponent } from '../common/component';
import { GREEN } from '../common/color'; import { GREEN } from '../common/color';
import { pageScrollMixin } from '../mixins/page-scroll'; import { pageScrollMixin } from '../mixins/page-scroll';
const indexList = () => { 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({ VantComponent({
relation: { relation: {
name: 'index-anchor', name: 'index-anchor',
type: 'descendant', type: 'descendant',
current: 'index-bar', current: 'index-bar',
linked() { linked() {
this.updateData(); this.updateData();
},
unlinked() {
this.updateData();
}
}, },
props: { unlinked() {
sticky: { this.updateData();
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) { props: {
this.scrollTop = event.scrollTop || 0; 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.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(); this.onScroll();
}) });
], }, 0);
data: { });
activeAnchorIndex: null,
showSidebar: false
}, },
created() { setRect() {
this.scrollTop = 0; return Promise.all([
this.setAnchorsRect(),
this.setListRect(),
this.setSiderbarRect(),
]);
}, },
methods: { setAnchorsRect() {
updateData() { return Promise.all(
wx.nextTick(() => { this.children.map((anchor) =>
if (this.timer != null) { anchor.getRect('.van-index-anchor-wrapper').then((rect) => {
clearTimeout(this.timer); Object.assign(anchor, {
} height: rect.height,
this.timer = setTimeout(() => { top: rect.top + this.scrollTop,
this.setData({
showSidebar: !!this.children.length
});
this.setRect().then(() => {
this.onScroll();
});
}, 0);
}); });
})
)
);
},
setListRect() {
return this.getRect('.van-index-bar').then((rect) => {
Object.assign(this, {
height: rect.height,
top: rect.top + this.scrollTop,
});
});
},
setSiderbarRect() {
return this.getRect('.van-index-bar__sidebar').then((res) => {
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 anchor.getRect('.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,
}, },
setRect() { });
return Promise.all([ if (sticky) {
this.setAnchorsRect(), let isActiveAnchorSticky = false;
this.setListRect(), if (active !== -1) {
this.setSiderbarRect() isActiveAnchorSticky =
]); children[active].top <= stickyOffsetTop + scrollTop;
}, }
setAnchorsRect() { children.forEach((item, index) => {
return Promise.all(this.children.map(anchor => anchor if (index === active) {
.getRect('.van-index-anchor-wrapper') let wrapperStyle = '';
.then((rect) => { let anchorStyle = `
Object.assign(anchor, {
height: rect.height,
top: rect.top + this.scrollTop
});
})));
},
setListRect() {
return this.getRect('.van-index-bar').then((rect) => {
Object.assign(this, {
height: rect.height,
top: rect.top + this.scrollTop
});
});
},
setSiderbarRect() {
return this.getRect('.van-index-bar__sidebar').then(res => {
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 anchor
.getRect('.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}; color: ${highlightColor};
`; `;
if (isActiveAnchorSticky) { if (isActiveAnchorSticky) {
wrapperStyle = ` wrapperStyle = `
height: ${children[index].height}px; height: ${children[index].height}px;
`; `;
anchorStyle = ` anchorStyle = `
position: fixed; position: fixed;
top: ${stickyOffsetTop}px; top: ${stickyOffsetTop}px;
z-index: ${zIndex}; z-index: ${zIndex};
color: ${highlightColor}; 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) {
else if (index === active - 1) { const currentAnchor = children[index];
const currentAnchor = children[index]; const currentOffsetTop = currentAnchor.top;
const currentOffsetTop = currentAnchor.top; const targetOffsetTop =
const targetOffsetTop = index === children.length - 1 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; position: relative;
transform: translate3d(0, ${translateY}px, 0); transform: translate3d(0, ${translateY}px, 0);
z-index: ${zIndex}; z-index: ${zIndex};
color: ${highlightColor}; color: ${highlightColor};
`; `;
this.setDiffData({ this.setDiffData({
target: item, target: item,
data: { data: {
active: true, active: true,
anchorStyle anchorStyle,
} },
}); });
} } else {
else { this.setDiffData({
this.setDiffData({ target: item,
target: item, data: {
data: { active: false,
active: false, anchorStyle: '',
anchorStyle: '', wrapperStyle: '',
wrapperStyle: '' },
} });
}); }
} });
}); }
} },
}, onClick(event) {
onClick(event) { this.scrollToAnchor(event.target.dataset.index);
this.scrollToAnchor(event.target.dataset.index); },
}, onTouchMove(event) {
onTouchMove(event) { const sidebarLength = this.children.length;
const sidebarLength = this.children.length; const touch = event.touches[0];
const touch = event.touches[0]; const itemHeight = this.sidebar.height / sidebarLength;
const itemHeight = this.sidebar.height / sidebarLength; let index = Math.floor((touch.clientY - this.sidebar.top) / itemHeight);
let index = Math.floor((touch.clientY - this.sidebar.top) / itemHeight); if (index < 0) {
if (index < 0) { index = 0;
index = 0; } else if (index > sidebarLength - 1) {
} index = sidebarLength - 1;
else if (index > sidebarLength - 1) { }
index = sidebarLength - 1; this.scrollToAnchor(index);
} },
this.scrollToAnchor(index); onTouchStop() {
}, this.scrollToAnchorIndex = null;
onTouchStop() { },
this.scrollToAnchorIndex = null; scrollToAnchor(index) {
}, if (typeof index !== 'number' || this.scrollToAnchorIndex === index) {
scrollToAnchor(index) { return;
if (typeof index !== 'number' || this.scrollToAnchorIndex === index) { }
return; this.scrollToAnchorIndex = index;
} const anchor = this.children.find(
this.scrollToAnchorIndex = index; (item) => item.data.index === this.data.indexList[index]
const anchor = this.children.find((item) => item.data.index === this.data.indexList[index]); );
if (anchor) { if (anchor) {
anchor.scrollIntoView(this.scrollTop); anchor.scrollIntoView(this.scrollTop);
this.$emit('select', anchor.data.index); this.$emit('select', anchor.data.index);
} }
} },
} },
}); });

10
dist/info/index.js vendored
View File

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

2
dist/info/index.wxss vendored
View File

@ -1 +1 @@
@import '../common/index.wxss';.van-info{position:absolute;top:0;right:0;box-sizing:border-box;white-space:nowrap;text-align:center;-webkit-transform:translate(50%,-50%);transform:translate(50%,-50%);-webkit-transform-origin:100%;transform-origin:100%;min-width:16px;min-width:var(--info-size,16px);padding:0 3px;padding:var(--info-padding,0 3px);color:#fff;color:var(--info-color,#fff);font-weight:500;font-weight:var(--info-font-weight,500);font-size:12px;font-size:var(--info-font-size,12px);font-family:PingFang SC,Helvetica Neue,Arial,sans-serif;font-family:var(--info-font-family,PingFang SC,Helvetica Neue,Arial,sans-serif);line-height:14px;line-height:calc(var(--info-size, 16px) - var(--info-border-width, 1px)*2);background-color:#ee0a24;background-color:var(--info-background-color,#ee0a24);border:1px solid #fff;border:var(--info-border-width,1px) solid var(--white,#fff);border-radius:16px;border-radius:var(--info-size,16px)}.van-info--dot{min-width:0;border-radius:100%;width:8px;width:var(--info-dot-size,8px);height:8px;height:var(--info-dot-size,8px);background-color:#ee0a24;background-color:var(--info-dot-color,#ee0a24)} @import '../common/index.wxss';.van-info{position:absolute;top:0;right:0;box-sizing:border-box;white-space:nowrap;text-align:center;-webkit-transform:translate(50%,-50%);transform:translate(50%,-50%);-webkit-transform-origin:100%;transform-origin:100%;min-width:16px;min-width:var(--info-size,16px);padding:0 3px;padding:var(--info-padding,0 3px);color:#fff;color:var(--info-color,#fff);font-weight:500;font-weight:var(--info-font-weight,500);font-size:12px;font-size:var(--info-font-size,12px);font-family:Avenir-Heavy,PingFang SC,Helvetica Neue,Arial,sans-serif;font-family:var(--info-font-family,Avenir-Heavy,PingFang SC,Helvetica Neue,Arial,sans-serif);line-height:14px;line-height:calc(var(--info-size, 16px) - var(--info-border-width, 1px)*2);background-color:#ee0a24;background-color:var(--info-background-color,#ee0a24);border:1px solid #fff;border:var(--info-border-width,1px) solid var(--white,#fff);border-radius:16px;border-radius:var(--info-size,16px)}.van-info--dot{min-width:0;border-radius:100%;width:8px;width:var(--info-dot-size,8px);height:8px;height:var(--info-dot-size,8px);background-color:#ee0a24;background-color:var(--info-dot-color,#ee0a24)}

24
dist/loading/index.js vendored
View File

@ -1,16 +1,16 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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 }),
},
}); });

2
dist/loading/index.json vendored
View File

@ -1,3 +1,3 @@
{ {
"component": true "component": true
} }

49
dist/mixins/basic.js vendored
View File

@ -1,26 +1,27 @@
export const basic = Behavior({ export const basic = Behavior({
methods: { methods: {
$emit(...args) { $emit(...args) {
this.triggerEvent(...args); this.triggerEvent(...args);
}, },
set(data, callback) { set(data, callback) {
this.setData(data, callback); this.setData(data, callback);
return new Promise(resolve => wx.nextTick(resolve)); return new Promise((resolve) => wx.nextTick(resolve));
}, },
getRect(selector, all) { getRect(selector, all) {
return new Promise(resolve => { return new Promise((resolve) => {
wx.createSelectorQuery() wx.createSelectorQuery()
.in(this)[all ? 'selectAll' : 'select'](selector) .in(this)
.boundingClientRect(rect => { [all ? 'selectAll' : 'select'](selector)
if (all && Array.isArray(rect) && rect.length) { .boundingClientRect((rect) => {
resolve(rect); if (all && Array.isArray(rect) && rect.length) {
} resolve(rect);
if (!all && rect) { }
resolve(rect); if (!all && rect) {
} resolve(rect);
}) }
.exec(); })
}); .exec();
} });
} },
},
}); });

26
dist/mixins/button.js vendored
View File

@ -1,15 +1,15 @@
export const button = Behavior({ 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,
} },
}); });

28
dist/mixins/link.js vendored
View File

@ -1,17 +1,17 @@
export const link = Behavior({ export const link = Behavior({
properties: { properties: {
url: String, url: String,
linkType: { linkType: {
type: String, type: String,
value: 'navigateTo' value: 'navigateTo',
}
}, },
methods: { },
jumpLink(urlKey = 'url') { methods: {
const url = this.data[urlKey]; jumpLink(urlKey = 'url') {
if (url) { const url = this.data[urlKey];
wx[this.data.linkType]({ url }); if (url) {
} wx[this.data.linkType]({ url });
} }
} },
},
}); });

44
dist/mixins/open-type.js vendored
View File

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

47
dist/mixins/page-scroll.js vendored
View File

@ -1,28 +1,33 @@
function getCurrentPage() { function getCurrentPage() {
const pages = getCurrentPages(); const pages = getCurrentPages();
return pages[pages.length - 1] || {}; return pages[pages.length - 1] || {};
} }
function onPageScroll(event) { function onPageScroll(event) {
const { vanPageScroller = [] } = getCurrentPage(); const { vanPageScroller = [] } = getCurrentPage();
vanPageScroller.forEach((scroller) => { vanPageScroller.forEach((scroller) => {
if (typeof scroller === 'function') { if (typeof scroller === 'function') {
scroller(event); scroller(event);
} }
}); });
} }
export const pageScrollMixin = (scroller) => Behavior({ export const pageScrollMixin = (scroller) =>
Behavior({
attached() { 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 {
else { page.vanPageScroller =
page.vanPageScroller = [page.onPageScroll, scroller.bind(this)]; typeof page.onPageScroll === 'function'
} ? [page.onPageScroll.bind(page), scroller.bind(this)]
page.onPageScroll = onPageScroll; : [scroller.bind(this)];
}
page.onPageScroll = onPageScroll;
}, },
detached() { detached() {
const page = getCurrentPage(); const page = getCurrentPage();
page.vanPageScroller = (page.vanPageScroller || []).filter(item => item !== scroller); page.vanPageScroller = (page.vanPageScroller || []).filter(
} (item) => item !== scroller
}); );
},
});

61
dist/mixins/touch.js vendored
View File

@ -1,35 +1,36 @@
const MIN_DISTANCE = 10; const MIN_DISTANCE = 10;
function getDirection(x, y) { 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({ 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) { touchStart(event) {
this.resetTouchStatus(); this.resetTouchStatus();
const touch = event.touches[0]; const touch = event.touches[0];
this.startX = touch.clientX; this.startX = touch.clientX;
this.startY = touch.clientY; this.startY = touch.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.direction || getDirection(this.offsetX, this.offsetY); this.direction =
} this.direction || getDirection(this.offsetX, this.offsetY);
} },
},
}); });

2
dist/mixins/transition.d.ts vendored
View File

@ -1 +1 @@
export declare const transition: (showDefaultValue: boolean) => any; export declare const transition: (showDefaultValue: boolean) => string;

224
dist/mixins/transition.js vendored
View File

@ -1,118 +1,118 @@
import { isObj } from '../common/utils'; import { isObj } from '../common/utils';
const getClassNames = (name) => ({ 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`,
}); });
const nextTick = () => new Promise(resolve => setTimeout(resolve, 1000 / 30)); const nextTick = () => new Promise((resolve) => setTimeout(resolve, 1000 / 30));
export const transition = function (showDefaultValue) { export const transition = function (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,
}, },
methods: { methods: {
observeShow(value, old) { observeShow(value, old) {
if (value === old) { if (value === old) {
return; 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');
Promise.resolve()
.then(nextTick)
.then(() => {
this.checkStatus('enter');
this.$emit('enter');
this.setData({
inited: true,
display: true,
classes: classNames.enter,
currentDuration
});
})
.then(nextTick)
.then(() => {
this.checkStatus('enter');
this.transitionEnded = false;
this.setData({
classes: classNames['enter-to']
});
})
.catch(() => { });
},
leave() {
if (!this.data.display) {
return;
}
const { duration, name } = this.data;
const classNames = getClassNames(name);
const currentDuration = isObj(duration) ? duration.leave : duration;
this.status = 'leave';
this.$emit('before-leave');
Promise.resolve()
.then(nextTick)
.then(() => {
this.checkStatus('leave');
this.$emit('leave');
this.setData({
classes: classNames.leave,
currentDuration
});
})
.then(nextTick)
.then(() => {
this.checkStatus('leave');
this.transitionEnded = false;
setTimeout(() => this.onTransitionEnd(), currentDuration);
this.setData({
classes: classNames['leave-to']
});
})
.catch(() => { });
},
checkStatus(status) {
if (status !== this.status) {
throw new Error(`incongruent status: ${status}`);
}
},
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 });
}
}
} }
}); 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');
Promise.resolve()
.then(nextTick)
.then(() => {
this.checkStatus('enter');
this.$emit('enter');
this.setData({
inited: true,
display: true,
classes: classNames.enter,
currentDuration,
});
})
.then(nextTick)
.then(() => {
this.checkStatus('enter');
this.transitionEnded = false;
this.setData({
classes: classNames['enter-to'],
});
})
.catch(() => {});
},
leave() {
if (!this.data.display) {
return;
}
const { duration, name } = this.data;
const classNames = getClassNames(name);
const currentDuration = isObj(duration) ? duration.leave : duration;
this.status = 'leave';
this.$emit('before-leave');
Promise.resolve()
.then(nextTick)
.then(() => {
this.checkStatus('leave');
this.$emit('leave');
this.setData({
classes: classNames.leave,
currentDuration,
});
})
.then(nextTick)
.then(() => {
this.checkStatus('leave');
this.transitionEnded = false;
setTimeout(() => this.onTransitionEnd(), currentDuration);
this.setData({
classes: classNames['leave-to'],
});
})
.catch(() => {});
},
checkStatus(status) {
if (status !== this.status) {
throw new Error(`incongruent status: ${status}`);
}
},
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 });
}
},
},
});
}; };

110
dist/nav-bar/index.js vendored
View File

@ -1,62 +1,62 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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,
leftArrow: Boolean,
border: {
type: Boolean,
value: true
},
zIndex: {
type: Number,
value: 1
},
safeAreaInsetTop: {
type: Boolean,
value: true
}
}, },
data: { placeholder: {
statusBarHeight: 0, type: Boolean,
height: 44 observer: 'setHeight',
}, },
created() { leftText: String,
const { statusBarHeight } = wx.getSystemInfoSync(); rightText: String,
this.setData({ leftArrow: Boolean,
statusBarHeight, border: {
height: 44 + statusBarHeight type: Boolean,
value: true,
},
zIndex: {
type: Number,
value: 1,
},
safeAreaInsetTop: {
type: Boolean,
value: true,
},
},
data: {
statusBarHeight: 0,
height: 44,
},
created() {
const { statusBarHeight } = wx.getSystemInfoSync();
this.setData({
statusBarHeight,
height: 44 + 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(() => {
this.getRect('.van-nav-bar').then((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(() => {
this.getRect('.van-nav-bar').then((res) => {
this.setData({ height: res.height });
});
});
}
}
}); });

240
dist/notice-bar/index.js vendored
View File

@ -2,127 +2,129 @@ import { VantComponent } from '../common/component';
const FONT_COLOR = '#ed6a0c'; const FONT_COLOR = '#ed6a0c';
const BG_COLOR = '#fffbe8'; const BG_COLOR = '#fffbe8';
VantComponent({ VantComponent({
props: { props: {
text: { text: {
type: String, type: String,
value: '', value: '',
observer() { observer() {
wx.nextTick(() => { wx.nextTick(() => {
this.init(); this.init();
});
},
},
mode: {
type: String,
value: ''
},
url: {
type: String,
value: ''
},
openType: {
type: String,
value: 'navigate'
},
delay: {
type: Number,
value: 1
},
speed: {
type: Number,
value: 50,
observer() {
wx.nextTick(() => {
this.init();
});
}
},
scrollable: {
type: Boolean,
value: true
},
leftIcon: {
type: String,
value: ''
},
color: {
type: String,
value: FONT_COLOR
},
backgroundColor: {
type: String,
value: BG_COLOR
},
wrapable: Boolean
},
data: {
show: true
},
created() {
this.resetAnimation = wx.createAnimation({
duration: 0,
timingFunction: 'linear'
}); });
},
}, },
destroyed() { mode: {
this.timer && clearTimeout(this.timer); type: String,
value: '',
}, },
methods: { url: {
init() { type: String,
Promise.all([ value: '',
this.getRect('.van-notice-bar__content'), },
this.getRect('.van-notice-bar__wrap') openType: {
]).then((rects) => { type: String,
const [contentRect, wrapRect] = rects; value: 'navigate',
if (contentRect == null || },
wrapRect == null || delay: {
!contentRect.width || type: Number,
!wrapRect.width) { value: 1,
return; },
} speed: {
const { speed, scrollable, delay } = this.data; type: Number,
if (scrollable && wrapRect.width < contentRect.width) { value: 50,
const duration = (contentRect.width / speed) * 1000; observer() {
this.wrapWidth = wrapRect.width; wx.nextTick(() => {
this.contentWidth = contentRect.width; this.init();
this.duration = duration; });
this.animation = wx.createAnimation({ },
duration, },
timingFunction: 'linear', scrollable: {
delay type: Boolean,
}); value: true,
this.scroll(); },
} leftIcon: {
}); type: String,
}, value: '',
scroll() { },
this.timer && clearTimeout(this.timer); color: {
this.timer = null; type: String,
this.setData({ value: FONT_COLOR,
animationData: this.resetAnimation },
.translateX(this.wrapWidth) backgroundColor: {
.step() type: String,
.export() value: BG_COLOR,
}); },
setTimeout(() => { wrapable: Boolean,
this.setData({ },
animationData: this.animation data: {
.translateX(-this.contentWidth) show: true,
.step() },
.export() created() {
}); this.resetAnimation = wx.createAnimation({
}, 20); duration: 0,
this.timer = setTimeout(() => { timingFunction: 'linear',
this.scroll(); });
}, this.duration); },
}, destroyed() {
onClickIcon() { this.timer && clearTimeout(this.timer);
this.timer && clearTimeout(this.timer); },
this.timer = null; methods: {
this.setData({ show: false }); init() {
}, Promise.all([
onClick(event) { this.getRect('.van-notice-bar__content'),
this.$emit('click', event); this.getRect('.van-notice-bar__wrap'),
]).then((rects) => {
const [contentRect, wrapRect] = rects;
if (
contentRect == null ||
wrapRect == null ||
!contentRect.width ||
!wrapRect.width
) {
return;
} }
} const { speed, scrollable, delay } = this.data;
if (scrollable && wrapRect.width < contentRect.width) {
const duration = (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(),
});
setTimeout(() => {
this.setData({
animationData: this.animation
.translateX(-this.contentWidth)
.step()
.export(),
});
}, 20);
this.timer = setTimeout(() => {
this.scroll();
}, this.duration);
},
onClickIcon() {
this.timer && clearTimeout(this.timer);
this.timer = null;
this.setData({ show: false });
},
onClick(event) {
this.$emit('click', event);
},
},
}); });

2
dist/notice-bar/index.json vendored
View File

@ -3,4 +3,4 @@
"usingComponents": { "usingComponents": {
"van-icon": "../icon/index" "van-icon": "../icon/index"
} }
} }

108
dist/notify/index.js vendored
View File

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

70
dist/notify/notify.js vendored
View File

@ -1,43 +1,49 @@
import { WHITE } from '../common/color'; import { WHITE } from '../common/color';
const defaultOptions = { 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) { function parseOptions(message) {
return typeof message === 'string' ? { message } : message; return typeof message === 'string' ? { message } : message;
} }
function getContext() { function getContext() {
const pages = getCurrentPages(); const pages = getCurrentPages();
return pages[pages.length - 1]; return pages[pages.length - 1];
} }
export default function Notify(options) { export default function Notify(options) {
options = Object.assign(Object.assign({}, defaultOptions), parseOptions(options)); options = Object.assign(
const context = options.context || getContext(); Object.assign({}, defaultOptions),
const notify = context.selectComponent(options.selector); parseOptions(options)
delete options.context; );
delete options.selector; const context = options.context || getContext();
if (notify) { const notify = context.selectComponent(options.selector);
notify.setData(options); delete options.context;
notify.show(); delete options.selector;
return notify; if (notify) {
} notify.setData(options);
console.warn('未找到 van-notify 节点，请确认 selector 及 context 是否正确'); notify.show();
return notify;
}
console.warn('未找到 van-notify 节点，请确认 selector 及 context 是否正确');
} }
Notify.clear = function (options) { Notify.clear = function (options) {
options = Object.assign(Object.assign({}, defaultOptions), parseOptions(options)); options = Object.assign(
const context = options.context || getContext(); Object.assign({}, defaultOptions),
const notify = context.selectComponent(options.selector); parseOptions(options)
if (notify) { );
notify.hide(); const context = options.context || getContext();
} const notify = context.selectComponent(options.selector);
if (notify) {
notify.hide();
}
}; };

36
dist/overlay/index.js vendored
View File

@ -1,22 +1,22 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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
}
}, },
methods: { zIndex: {
onClick() { type: Number,
this.$emit('click'); value: 1,
}, },
// for prevent touchmove },
noop() { } methods: {
} onClick() {
this.$emit('click');
},
// for prevent touchmove
noop() {},
},
}); });

14
dist/panel/index.js vendored
View File

@ -1,10 +1,10 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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,
useFooterSlot: Boolean useFooterSlot: Boolean,
} },
}); });

218
dist/picker-column/index.js vendored
View File

@ -2,116 +2,122 @@ import { VantComponent } from '../common/component';
import { isObj, range } from '../common/utils'; import { isObj, range } from '../common/utils';
const DEFAULT_DURATION = 200; const DEFAULT_DURATION = 200;
VantComponent({ 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);
}
}
}, },
data: { defaultIndex: {
startY: 0, type: Number,
offset: 0, value: 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, duration: 0,
startOffset: 0, });
options: [],
currentIndex: 0
}, },
created() { onTouchMove(event) {
const { defaultIndex, initialOptions } = this.data; const { data } = this;
this.set({ const deltaY = event.touches[0].clientY - data.startY;
currentIndex: defaultIndex, this.setData({
options: initialOptions offset: range(
}).then(() => { data.startOffset + deltaY,
this.setIndex(defaultIndex); -(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 });
}, },
methods: { setValue(value) {
getCount() { const { options } = this.data;
return this.data.options.length; for (let i = 0; i < options.length; i++) {
}, if (this.getOptionText(options[i]) === value) {
onTouchStart(event) { return this.setIndex(i);
this.setData({
startY: event.touches[0].clientY,
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];
} }
} }
return Promise.resolve();
},
getValue() {
const { data } = this;
return data.options[data.currentIndex];
},
},
}); });

2
dist/picker-column/index.json vendored
View File

@ -1,3 +1,3 @@
{ {
"component": true "component": true
} }

268
dist/picker/index.js vendored
View File

@ -1,135 +1,145 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { pickerProps } from './shared'; import { pickerProps } from './shared';
VantComponent({ VantComponent({
classes: ['active-class', 'toolbar-class', 'column-class'], classes: ['active-class', 'toolbar-class', 'column-class'],
props: Object.assign(Object.assign({}, pickerProps), { valueKey: { props: Object.assign(Object.assign({}, pickerProps), {
type: String, valueKey: {
value: 'text' type: String,
}, toolbarPosition: { value: 'text',
type: String,
value: 'top'
}, defaultIndex: {
type: Number,
value: 0
}, columns: {
type: Array,
value: [],
observer(columns = []) {
this.simple = columns.length && !columns[0].values;
this.children = this.selectAllComponents('.van-picker__column');
if (Array.isArray(this.children) && this.children.length) {
this.setColumns().catch(() => { });
}
}
} }),
beforeCreate() {
this.children = [];
}, },
methods: { toolbarPosition: {
noop() { }, type: String,
setColumns() { value: 'top',
const { data } = this; },
const columns = this.simple ? [{ values: data.columns }] : data.columns; defaultIndex: {
const stack = columns.map((column, index) => this.setColumnValues(index, column.values)); type: Number,
return Promise.all(stack); value: 0,
}, },
emit(event) { columns: {
const { type } = event.currentTarget.dataset; type: Array,
if (this.simple) { value: [],
this.$emit(type, { observer(columns = []) {
value: this.getColumnValue(0), this.simple = columns.length && !columns[0].values;
index: this.getColumnIndex(0) this.children = this.selectAllComponents('.van-picker__column');
}); if (Array.isArray(this.children) && this.children.length) {
} this.setColumns().catch(() => {});
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);
} }
} },
},
}),
beforeCreate() {
this.children = [];
},
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) {
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);
},
},
}); });

38
dist/picker/shared.js vendored
View File

@ -1,21 +1,21 @@
export const pickerProps = { 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: 5 value: 5,
}, },
itemHeight: { itemHeight: {
type: Number, type: Number,
value: 44 value: 44,
} },
}; };

150
dist/popup/index.js vendored
View File

@ -1,81 +1,81 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { transition } from '../mixins/transition'; import { transition } from '../mixins/transition';
VantComponent({ 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
}
}, },
created() { zIndex: {
this.observeClass(); type: Number,
value: 100,
}, },
methods: { overlay: {
onClickCloseIcon() { type: Boolean,
this.$emit('close'); value: true,
}, },
onClickOverlay() { closeIcon: {
this.$emit('click-overlay'); type: String,
if (this.data.closeOnClickOverlay) { value: 'cross',
this.$emit('close'); },
} closeIconPosition: {
}, type: String,
observeClass() { value: 'top-right',
const { transition, position } = this.data; },
const updateData = { closeOnClickOverlay: {
name: transition || position type: Boolean,
}; value: true,
if (transition === 'none') { },
updateData.duration = 0; position: {
} type: String,
this.setData(updateData); value: 'center',
} observer: 'observeClass',
} },
safeAreaInsetBottom: {
type: Boolean,
value: true,
},
safeAreaInsetTop: {
type: Boolean,
value: false,
},
},
created() {
this.observeClass();
},
methods: {
onClickCloseIcon() {
this.$emit('close');
},
onClickOverlay() {
this.$emit('click-overlay');
if (this.data.closeOnClickOverlay) {
this.$emit('close');
}
},
observeClass() {
const { transition, position } = this.data;
const updateData = {
name: transition || position,
};
if (transition === 'none') {
updateData.duration = 0;
}
this.setData(updateData);
},
},
}); });

46
dist/progress/index.js vendored
View File

@ -1,27 +1,27 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { BLUE } from '../common/color'; import { BLUE } from '../common/color';
VantComponent({ VantComponent({
props: { props: {
inactive: Boolean, inactive: Boolean,
percentage: Number, percentage: Number,
pivotText: String, pivotText: String,
pivotColor: String, pivotColor: String,
trackColor: String, trackColor: String,
showPivot: { showPivot: {
type: Boolean, type: Boolean,
value: true value: true,
}, },
color: { color: {
type: String, type: String,
value: BLUE value: BLUE,
}, },
textColor: { textColor: {
type: String, type: String,
value: '#fff' value: '#fff',
}, },
strokeWidth: { strokeWidth: {
type: null, type: null,
value: 4 value: 4,
} },
} },
}); });

58
dist/radio-group/index.js vendored
View File

@ -1,34 +1,34 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
field: true, field: true,
relation: { relation: {
name: 'radio', name: 'radio',
type: 'descendant', type: 'descendant',
current: 'radio-group', current: 'radio-group',
linked(target) { linked(target) {
this.updateChild(target); this.updateChild(target);
},
}, },
props: { },
value: { props: {
type: null, value: {
observer: 'updateChildren' type: null,
}, observer: 'updateChildren',
disabled: {
type: Boolean,
observer: 'updateChildren'
}
}, },
methods: { disabled: {
updateChildren() { type: Boolean,
(this.children || []).forEach((child) => this.updateChild(child)); observer: 'updateChildren',
}, },
updateChild(child) { },
const { value, disabled } = this.data; methods: {
child.setData({ updateChildren() {
value, (this.children || []).forEach((child) => this.updateChild(child));
disabled: disabled || child.data.disabled },
}); updateChild(child) {
} const { value, disabled } = this.data;
} child.setData({
value,
disabled: disabled || child.data.disabled,
});
},
},
}); });

86
dist/radio/index.js vendored
View File

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

153
dist/rate/index.js vendored
View File

@ -1,80 +1,87 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { canIUseModel } from '../common/version';
VantComponent({ 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: {
type: String,
value: '#ffd21e'
},
voidColor: {
type: String,
value: '#c7c7c7'
},
disabledColor: {
type: String,
value: '#bdbdbd'
},
count: {
type: Number,
value: 5,
observer(value) {
this.setData({ innerCountArray: Array.from({ length: value }) });
},
},
gutter: null,
touchable: {
type: Boolean,
value: true
} }
},
}, },
data: { readonly: Boolean,
innerValue: 0, disabled: Boolean,
innerCountArray: Array.from({ length: 5 }), allowHalf: Boolean,
size: null,
icon: {
type: String,
value: 'star',
}, },
methods: { voidIcon: {
onSelect(event) { type: String,
const { data } = this; value: 'star-o',
const { score } = event.currentTarget.dataset; },
if (!data.disabled && !data.readonly) { color: {
this.setData({ innerValue: score + 1 }); type: String,
this.$emit('input', score + 1); value: '#ffd21e',
this.$emit('change', score + 1); },
} voidColor: {
}, type: String,
onTouchMove(event) { value: '#c7c7c7',
const { touchable } = this.data; },
if (!touchable) disabledColor: {
return; type: String,
const { clientX } = event.touches[0]; value: '#bdbdbd',
this.getRect('.van-rate__icon', true).then((list) => { },
const target = list count: {
.sort(item => item.right - item.left) type: Number,
.find(item => clientX >= item.left && clientX <= item.right); value: 5,
if (target != null) { observer(value) {
this.onSelect(Object.assign(Object.assign({}, event), { currentTarget: target })); 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];
this.getRect('.van-rate__icon', true).then((list) => {
const target = list
.sort((item) => item.right - item.left)
.find((item) => clientX >= item.left && clientX <= item.right);
if (target != null) {
this.onSelect(
Object.assign(Object.assign({}, event), { currentTarget: target })
);
}
});
},
},
}); });

68
dist/row/index.js vendored
View File

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

143
dist/search/index.js vendored
View File

@ -1,73 +1,78 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { canIUseModel } from '../common/version';
VantComponent({ 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
}
}, },
methods: { rightIcon: String,
onChange(event) { placeholder: String,
this.setData({ value: event.detail }); placeholderStyle: String,
this.$emit('change', event.detail); actionText: {
}, type: String,
onCancel() { value: '取消',
/** },
* 修复修改输入框值时，输入框失焦和赋值同时触发，赋值失效 background: {
* https://github.com/youzan/@vant/weapp/issues/1768 type: String,
*/ value: '#ffffff',
setTimeout(() => { },
this.setData({ value: '' }); maxlength: {
this.$emit('cancel'); type: Number,
this.$emit('change', ''); value: -1,
}, 200); },
}, shape: {
onSearch() { type: String,
this.$emit('search', this.data.value); value: 'square',
}, },
onFocus() { clearable: {
this.$emit('focus'); type: Boolean,
}, value: true,
onBlur() { },
this.$emit('blur'); },
}, methods: {
onClear() { onChange(event) {
this.$emit('clear'); 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);
},
},
}); });

55
dist/sidebar-item/index.js vendored
View File

@ -1,34 +1,31 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
classes: [ classes: ['active-class', 'disabled-class'],
'active-class', relation: {
'disabled-class', type: 'ancestor',
], name: 'sidebar',
relation: { current: 'sidebar-item',
type: 'ancestor', },
name: 'sidebar', props: {
current: 'sidebar-item', dot: Boolean,
info: null,
title: String,
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);
});
}, },
props: { setActive(selected) {
dot: Boolean, return this.setData({ selected });
info: null,
title: String,
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) {
return this.setData({ selected });
}
}
}); });

70
dist/sidebar/index.js vendored
View File

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

84
dist/skeleton/index.js vendored
View File

@ -1,46 +1,46 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ 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 });
}
}
}, },
data: { title: Boolean,
isArray: false, avatar: Boolean,
rowArray: [], 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 });
},
},
},
data: {
isArray: false,
rowArray: [],
},
}); });

2
dist/skeleton/index.json vendored
View File

@ -1,4 +1,4 @@
{ {
"component": true, "component": true,
"usingComponents": {} "usingComponents": {}
} }

189
dist/slider/index.js vendored
View File

@ -1,105 +1,102 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { touch } from '../mixins/touch'; import { touch } from '../mixins/touch';
import { addUnit } from '../common/utils'; import { canIUseModel } from '../common/version';
VantComponent({ VantComponent({
mixins: [touch], mixins: [touch],
props: { props: {
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: Number,
value: 0,
observer(value) {
this.updateValue(value, false);
}
},
barHeight: {
type: null,
value: '2px'
}
}, },
created() { min: {
this.updateValue(this.data.value); type: Number,
value: 0,
}, },
methods: { step: {
onTouchStart(event) { type: Number,
if (this.data.disabled) value: 1,
return; },
this.touchStart(event); value: {
this.startValue = this.format(this.data.value); type: Number,
this.dragStatus = 'start'; value: 0,
}, observer: 'updateValue',
onTouchMove(event) { },
if (this.data.disabled) barHeight: {
return; type: null,
if (this.dragStatus === 'start') { value: '2px',
this.$emit('drag-start'); },
} },
this.touchMove(event); created() {
this.dragStatus = 'draging'; this.updateValue(this.data.value);
this.getRect('.van-slider').then((rect) => { },
const diff = (this.deltaX / rect.width) * 100; methods: {
this.newValue = this.startValue + diff; onTouchStart(event) {
this.updateValue(this.newValue, false, true); if (this.data.disabled) return;
}); this.touchStart(event);
}, this.startValue = this.format(this.data.value);
onTouchEnd() { this.dragStatus = 'start';
if (this.data.disabled) },
return; onTouchMove(event) {
if (this.dragStatus === 'draging') { if (this.data.disabled) return;
this.updateValue(this.newValue, true); if (this.dragStatus === 'start') {
this.$emit('drag-end'); this.$emit('drag-start');
} }
}, this.touchMove(event);
onClick(event) { this.dragStatus = 'draging';
if (this.data.disabled) this.getRect('.van-slider').then((rect) => {
return; const diff = (this.deltaX / rect.width) * 100;
const { min } = this.data; this.newValue = this.startValue + diff;
this.getRect('.van-slider').then((rect) => { this.updateValue(this.newValue, false, true);
const value = ((event.detail.x - rect.left) / rect.width) * this.getRange() + min; });
this.updateValue(value, true); },
}); onTouchEnd() {
}, if (this.data.disabled) return;
updateValue(value, end, drag) { if (this.dragStatus === 'draging') {
value = this.format(value); this.updateValue(this.newValue, true);
const { barHeight, min } = this.data; this.$emit('drag-end');
const width = `${((value - min) * 100) / this.getRange()}%`; }
this.setData({ },
value, onClick(event) {
barStyle: ` if (this.data.disabled) return;
const { min } = this.data;
this.getRect('.van-slider').then((rect) => {
const value =
((event.detail.x - rect.left) / rect.width) * this.getRange() + min;
this.updateValue(value, true);
});
},
updateValue(value, end, drag) {
value = this.format(value);
const { min } = this.data;
const width = `${((value - min) * 100) / this.getRange()}%`;
this.setData({
value,
barStyle: `
width: ${width}; width: ${width};
height: ${addUnit(barHeight)};
${drag ? 'transition: none;' : ''} ${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()) {
getRange() { this.setData({ value });
const { max, min } = this.data; }
return max - min; },
}, getRange() {
format(value) { const { max, min } = this.data;
const { max, min, step } = this.data; return max - min;
return Math.round(Math.max(min, Math.min(value, max)) / step) * step; },
} format(value) {
} const { max, min, step } = this.data;
return Math.round(Math.max(min, Math.min(value, max)) / step) * step;
},
},
}); });

3
dist/slider/index.wxml vendored
View File

@ -1,4 +1,5 @@
<wxs src="../wxs/utils.wxs" module="utils" /> <wxs src="../wxs/utils.wxs" module="utils" />
<wxs src="./index.wxs" module="computed" />
<view <view
class="custom-class {{ utils.bem('slider', { disabled }) }}" class="custom-class {{ utils.bem('slider', { disabled }) }}"
@ -7,7 +8,7 @@
> >
<view <view
class="van-slider__bar" class="van-slider__bar"
style="{{ barStyle }}; {{ activeColor ? 'background:' + activeColor : '' }}" style="{{ barStyle }};{{ computed.barStyle(barHeight, activeColor) }}"
> >
<view <view
class="van-slider__button-wrapper" class="van-slider__button-wrapper"

20
dist/slider/index.wxs vendored Normal file
View File

@ -0,0 +1,20 @@
/* eslint-disable */
var utils = require('../wxs/utils.wxs');
function barStyle(barHeight, activeColor) {
var styles = [['height', utils.addUnit(barHeight)]];
if (activeColor) {
styles.push(['background', activeColor]);
}
return styles
.map(function (item) {
return item.join(':');
})
.join(';');
}
module.exports = {
barStyle: barStyle,
};

345
dist/stepper/index.js vendored
View File

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

2
dist/stepper/index.json vendored
View File

@ -1,3 +1,3 @@
{ {
"component": true "component": true
} }

54
dist/steps/index.js vendored
View File

@ -1,33 +1,33 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
import { GREEN, GRAY_DARK } from '../common/color'; import { GREEN, GRAY_DARK } from '../common/color';
VantComponent({ 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
}, },
methods: { activeColor: {
onClick(event) { type: String,
const { index } = event.currentTarget.dataset; value: GREEN,
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);
},
},
}); });

188
dist/sticky/index.js vendored
View File

@ -2,98 +2,108 @@ import { VantComponent } from '../common/component';
import { pageScrollMixin } from '../mixins/page-scroll'; import { pageScrollMixin } from '../mixins/page-scroll';
const ROOT_ELEMENT = '.van-sticky'; const ROOT_ELEMENT = '.van-sticky';
VantComponent({ 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'
}
}, },
mixins: [ offsetTop: {
pageScrollMixin(function (event) { type: Number,
this.onScroll(event); value: 0,
}) observer: 'onScroll',
],
data: {
height: 0,
fixed: false,
transform: 0
}, },
mounted() { disabled: {
this.onScroll(); type: Boolean,
observer: 'onScroll',
}, },
methods: { container: {
onScroll({ scrollTop } = {}) { type: null,
const { container, offsetTop, disabled } = this.data; observer: 'onScroll',
if (disabled) { },
this.setDataAfterDiff({ scrollTop: {
fixed: false, type: null,
transform: 0 observer(val) {
}); this.onScroll({ scrollTop: val });
return; },
},
},
mixins: [
pageScrollMixin(function (event) {
if (this.data.scrollTop != null) {
return;
}
this.onScroll(event);
}),
],
data: {
height: 0,
fixed: false,
transform: 0,
},
mounted() {
this.onScroll();
},
methods: {
onScroll({ scrollTop } = {}) {
const { container, offsetTop, disabled } = this.data;
if (disabled) {
this.setDataAfterDiff({
fixed: false,
transform: 0,
});
return;
}
this.scrollTop = scrollTop || this.scrollTop;
if (typeof container === 'function') {
Promise.all([this.getRect(ROOT_ELEMENT), this.getContainerRect()]).then(
([root, container]) => {
if (offsetTop + root.height > container.height + container.top) {
this.setDataAfterDiff({
fixed: false,
transform: container.height - root.height,
});
} else if (offsetTop >= root.top) {
this.setDataAfterDiff({
fixed: true,
height: root.height,
transform: 0,
});
} else {
this.setDataAfterDiff({ fixed: false, transform: 0 });
} }
this.scrollTop = scrollTop || this.scrollTop; }
if (typeof container === 'function') { );
Promise.all([this.getRect(ROOT_ELEMENT), this.getContainerRect()]).then(([root, container]) => { return;
if (offsetTop + root.height > container.height + container.top) { }
this.setDataAfterDiff({ this.getRect(ROOT_ELEMENT).then((root) => {
fixed: false, if (offsetTop >= root.top) {
transform: container.height - root.height this.setDataAfterDiff({ fixed: true, height: root.height });
}); this.transform = 0;
} } else {
else if (offsetTop >= root.top) { this.setDataAfterDiff({ fixed: false });
this.setDataAfterDiff({
fixed: true,
height: root.height,
transform: 0
});
}
else {
this.setDataAfterDiff({ fixed: false, transform: 0 });
}
});
return;
}
this.getRect(ROOT_ELEMENT).then((root) => {
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;
}, {});
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());
} }
} });
},
setDataAfterDiff(data) {
wx.nextTick(() => {
const diff = Object.keys(data).reduce((prev, key) => {
if (data[key] !== this.data[key]) {
prev[key] = data[key];
}
return prev;
}, {});
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()
);
},
},
}); });

108
dist/submit-bar/index.js vendored
View File

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

4
dist/submit-bar/index.wxml vendored
View File

@ -16,7 +16,7 @@
<slot name="tip" /> <slot name="tip" />
</view> </view>
<view class="bar-class {{ utils.bem('submit-bar__bar', { safe: safeAreaInsetBottom }) }}"> <view class="bar-class van-submit-bar__bar">
<slot /> <slot />
<view wx:if="{{ hasPrice }}" class="van-submit-bar__text"> <view wx:if="{{ hasPrice }}" class="van-submit-bar__text">
<text>{{ label || '合计：' }}</text> <text>{{ label || '合计：' }}</text>
@ -39,4 +39,6 @@
{{ loading ? '' : buttonText }} {{ loading ? '' : buttonText }}
</van-button> </van-button>
</view> </view>
<view wx:if="{{ safeAreaInsetBottom }}" class="van-submit-bar__safe" />
</view> </view>

2
dist/submit-bar/index.wxss vendored
View File

@ -1 +1 @@
@import '../common/index.wxss';.van-submit-bar{position:fixed;bottom:0;left:0;width:100%;-webkit-user-select:none;user-select:none;z-index:100;z-index:var(--submit-bar-z-index,100);background-color:#fff;background-color:var(--submit-bar-background-color,#fff)}.van-submit-bar__tip{padding:10px;padding:var(--submit-bar-tip-padding,10px);color:#f56723;color:var(--submit-bar-tip-color,#f56723);font-size:12px;font-size:var(--submit-bar-tip-font-size,12px);line-height:1.5;line-height:var(--submit-bar-tip-line-height,1.5);background-color:#fff7cc;background-color:var(--submit-bar-tip-background-color,#fff7cc)}.van-submit-bar__tip:empty{display:none}.van-submit-bar__tip-icon{width:12px;height:12px;margin-right:4px;vertical-align:middle;font-size:12px;font-size:var(--submit-bar-tip-icon-size,12px);min-width:18px;min-width:calc(var(--submit-bar-tip-icon-size, 12px)*1.5)}.van-submit-bar__tip-text{display:inline;vertical-align:middle}.van-submit-bar__bar{display:-webkit-flex;display:flex;-webkit-align-items:center;align-items:center;-webkit-justify-content:flex-end;justify-content:flex-end;padding:0 16px;padding:var(--submit-bar-padding,0 16px);height:50px;height:var(--submit-bar-height,50px);font-size:14px;font-size:var(--submit-bar-text-font-size,14px);background-color:#fff;background-color:var(--submit-bar-background-color,#fff)}.van-submit-bar__bar--safe{padding-bottom:env(safe-area-inset-bottom)}.van-submit-bar__text{-webkit-flex:1;flex:1;text-align:right;color:#323233;color:var(--submit-bar-text-color,#323233);padding-right:12px;padding-right:var(--padding-sm,12px)}.van-submit-bar__price,.van-submit-bar__text{font-weight:500;font-weight:var(--font-weight-bold,500)}.van-submit-bar__price{color:#ee0a24;color:var(--submit-bar-price-color,#ee0a24);font-size:12px;font-size:var(--submit-bar-price-font-size,12px)}.van-submit-bar__price-integer{font-size:20px;font-family:Avenir-Heavy,PingFang SC,Helvetica Neue,Arial,sans-serif}.van-submit-bar__currency{font-size:12px;font-size:var(--submit-bar-currency-font-size,12px)}.van-submit-bar__suffix-label{margin-left:5px}.van-submit-bar__button{width:110px;width:var(--submit-bar-button-width,110px);font-weight:500;font-weight:var(--font-weight-bold,500);--button-default-height:40px!important;--button-default-height:var(--submit-bar-button-height,40px)!important;--button-line-height:40px!important;--button-line-height:var(--submit-bar-button-height,40px)!important} @import '../common/index.wxss';.van-submit-bar{position:fixed;bottom:0;left:0;width:100%;-webkit-user-select:none;user-select:none;z-index:100;z-index:var(--submit-bar-z-index,100);background-color:#fff;background-color:var(--submit-bar-background-color,#fff)}.van-submit-bar__tip{padding:10px;padding:var(--submit-bar-tip-padding,10px);color:#f56723;color:var(--submit-bar-tip-color,#f56723);font-size:12px;font-size:var(--submit-bar-tip-font-size,12px);line-height:1.5;line-height:var(--submit-bar-tip-line-height,1.5);background-color:#fff7cc;background-color:var(--submit-bar-tip-background-color,#fff7cc)}.van-submit-bar__tip:empty{display:none}.van-submit-bar__tip-icon{width:12px;height:12px;margin-right:4px;vertical-align:middle;font-size:12px;font-size:var(--submit-bar-tip-icon-size,12px);min-width:18px;min-width:calc(var(--submit-bar-tip-icon-size, 12px)*1.5)}.van-submit-bar__tip-text{display:inline;vertical-align:middle}.van-submit-bar__bar{display:-webkit-flex;display:flex;-webkit-align-items:center;align-items:center;-webkit-justify-content:flex-end;justify-content:flex-end;padding:0 16px;padding:var(--submit-bar-padding,0 16px);height:50px;height:var(--submit-bar-height,50px);font-size:14px;font-size:var(--submit-bar-text-font-size,14px);background-color:#fff;background-color:var(--submit-bar-background-color,#fff)}.van-submit-bar__safe{height:constant(safe-area-inset-bottom);height:env(safe-area-inset-bottom)}.van-submit-bar__text{-webkit-flex:1;flex:1;text-align:right;color:#323233;color:var(--submit-bar-text-color,#323233);padding-right:12px;padding-right:var(--padding-sm,12px)}.van-submit-bar__price,.van-submit-bar__text{font-weight:500;font-weight:var(--font-weight-bold,500)}.van-submit-bar__price{color:#ee0a24;color:var(--submit-bar-price-color,#ee0a24);font-size:12px;font-size:var(--submit-bar-price-font-size,12px)}.van-submit-bar__price-integer{font-size:20px;font-family:Avenir-Heavy,PingFang SC,Helvetica Neue,Arial,sans-serif}.van-submit-bar__currency{font-size:12px;font-size:var(--submit-bar-currency-font-size,12px)}.van-submit-bar__suffix-label{margin-left:5px}.van-submit-bar__button{width:110px;width:var(--submit-bar-button-width,110px);font-weight:500;font-weight:var(--font-weight-bold,500);--button-default-height:40px!important;--button-default-height:var(--submit-bar-button-height,40px)!important;--button-line-height:40px!important;--button-line-height:var(--submit-bar-button-height,40px)!important}

229
dist/swipe-cell/index.js vendored
View File

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

88
dist/switch/index.js vendored
View File

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

106
dist/tab/index.js vendored
View File

@ -1,59 +1,59 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
relation: { relation: {
name: 'tabs', name: 'tabs',
type: 'ancestor', type: 'ancestor',
current: 'tab', current: 'tab',
},
props: {
dot: {
type: Boolean,
observer: 'update',
}, },
props: { info: {
dot: { type: null,
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: [Number, String],
value: '',
}
}, },
data: { title: {
active: false type: String,
observer: 'update',
}, },
methods: { disabled: {
getComputedName() { type: Boolean,
if (this.data.name !== '') { observer: 'update',
return this.data.name; },
} titleStyle: {
return this.index; type: String,
}, observer: 'update',
updateRender(active, parent) { },
const { data: parentData } = parent; name: {
this.inited = this.inited || active; type: [Number, String],
this.setData({ value: '',
active, },
shouldRender: this.inited || !parentData.lazyRender, },
shouldShow: active || parentData.animated data: {
}); active: false,
}, },
update() { methods: {
if (this.parent) { getComputedName() {
this.parent.updateTabs(); 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();
}
},
},
}); });

2
dist/tab/index.json vendored
View File

@ -1,3 +1,3 @@
{ {
"component": true "component": true
} }

86
dist/tabbar-item/index.js vendored
View File

@ -1,48 +1,48 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
props: { props: {
info: null, info: null,
name: null, name: null,
icon: String, icon: String,
dot: Boolean dot: Boolean,
},
relation: {
name: 'tabbar',
type: 'ancestor',
current: 'tabbar-item',
},
data: {
active: false,
},
methods: {
onClick() {
if (this.parent) {
this.parent.onChange(this);
}
this.$emit('click');
}, },
relation: { updateFromParent() {
name: 'tabbar', const { parent } = this;
type: 'ancestor', if (!parent) {
current: 'tabbar-item', return;
}
const index = parent.children.indexOf(this);
const parentData = parent.data;
const { data } = this;
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;
}
return Object.keys(patch).length > 0
? this.set(patch)
: Promise.resolve();
}, },
data: { },
active: false
},
methods: {
onClick() {
if (this.parent) {
this.parent.onChange(this);
}
this.$emit('click');
},
updateFromParent() {
const { parent } = this;
if (!parent) {
return;
}
const index = parent.children.indexOf(this);
const parentData = parent.data;
const { data } = this;
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;
}
return Object.keys(patch).length > 0
? this.set(patch)
: Promise.resolve();
}
}
}); });

112
dist/tabbar/index.js vendored
View File

@ -1,61 +1,61 @@
import { VantComponent } from '../common/component'; import { VantComponent } from '../common/component';
VantComponent({ VantComponent({
relation: { relation: {
name: 'tabbar-item', name: 'tabbar-item',
type: 'descendant', type: 'descendant',
current: 'tabbar', current: 'tabbar',
linked(target) { linked(target) {
target.parent = this; target.parent = this;
target.updateFromParent(); target.updateFromParent();
},
unlinked() {
this.updateChildren();
}
}, },
props: { unlinked() {
active: { this.updateChildren();
type: null,
observer: 'updateChildren'
},
activeColor: {
type: String,
observer: 'updateChildren'
},
inactiveColor: {
type: String,
observer: 'updateChildren'
},
fixed: {
type: Boolean,
value: true
},
border: {
type: Boolean,
value: true
},
zIndex: {
type: Number,
value: 1
},
safeAreaInsetBottom: {
type: Boolean,
value: true
}
}, },
methods: { },
updateChildren() { props: {
const { children } = this; active: {
if (!Array.isArray(children) || !children.length) { type: null,
return Promise.resolve(); observer: 'updateChildren',
} },
return Promise.all(children.map((child) => child.updateFromParent())); activeColor: {
}, type: String,
onChange(child) { observer: 'updateChildren',
const index = this.children.indexOf(child); },
const active = child.data.name || index; inactiveColor: {
if (active !== this.data.active) { type: String,
this.$emit('change', active); observer: 'updateChildren',
} },
} fixed: {
} type: Boolean,
value: true,
},
border: {
type: Boolean,
value: true,
},
zIndex: {
type: Number,
value: 1,
},
safeAreaInsetBottom: {
type: Boolean,
value: true,
},
},
methods: {
updateChildren() {
const { children } = this;
if (!Array.isArray(children) || !children.length) {
return Promise.resolve();
}
return Promise.all(children.map((child) => child.updateFromParent()));
},
onChange(child) {
const index = this.children.indexOf(child);
const active = child.data.name || index;
if (active !== this.data.active) {
this.$emit('change', active);
}
},
},
}); });

Some files were not shown because too many files have changed in this diff Show More