chore[litemall-wx]: 使用vant-weapp 1.0

litemall-wx/lib/vant-weapp/count-down/utils.d.ts

+export declare type TimeData = {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+};
+export declare function parseTimeData(time: number): TimeData;
+export declare function parseFormat(format: string, timeData: TimeData): string;
+export declare function isSameSecond(time1: number, time2: number): boolean;

litemall-wx/lib/vant-weapp/count-down/utils.js

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

litemall-wx/lib/vant-weapp/datetime-picker/index.d.ts

+export {};

litemall-wx/lib/vant-weapp/datetime-picker/index.js

+import { VantComponent } from '../common/component';
+import { isDef } from '../common/utils';
+import { pickerProps } from '../picker/shared';
+const currentYear = new Date().getFullYear();
+function isValidDate(date) {
+    return isDef(date) && !isNaN(new Date(date).getTime());
+}
+function range(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+function padZero(val) {
+    return `00${val}`.slice(-2);
+}
+function times(n, iteratee) {
+    let index = -1;
+    const result = Array(n < 0 ? 0 : n);
+    while (++index < n) {
+        result[index] = iteratee(index);
+    }
+    return result;
+}
+function getTrueValue(formattedValue) {
+    if (!formattedValue)
+        return;
+    while (isNaN(parseInt(formattedValue, 10))) {
+        formattedValue = formattedValue.slice(1);
+    }
+    return parseInt(formattedValue, 10);
+}
+function getMonthEndDay(year, month) {
+    return 32 - new Date(year, month - 1, 32).getDate();
+}
+const defaultFormatter = (_, value) => value;
+VantComponent({
+    classes: ['active-class', 'toolbar-class', 'column-class'],
+    props: Object.assign(Object.assign({}, pickerProps), { value: null, filter: null, type: {
+            type: String,
+            value: 'datetime'
+        }, showToolbar: {
+            type: Boolean,
+            value: true
+        }, formatter: {
+            type: null,
+            value: defaultFormatter
+        }, minDate: {
+            type: Number,
+            value: new Date(currentYear - 10, 0, 1).getTime()
+        }, maxDate: {
+            type: Number,
+            value: new Date(currentYear + 10, 11, 31).getTime()
+        }, minHour: {
+            type: Number,
+            value: 0
+        }, maxHour: {
+            type: Number,
+            value: 23
+        }, minMinute: {
+            type: Number,
+            value: 0
+        }, maxMinute: {
+            type: Number,
+            value: 59
+        } }),
+    data: {
+        innerValue: Date.now(),
+        columns: []
+    },
+    watch: {
+        value: 'updateValue',
+        type: 'updateValue',
+        minDate: 'updateValue',
+        maxDate: 'updateValue',
+        minHour: 'updateValue',
+        maxHour: 'updateValue',
+        minMinute: 'updateValue',
+        maxMinute: 'updateValue'
+    },
+    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);
+        });
+    }
+});

litemall-wx/lib/vant-weapp/datetime-picker/index.json

+{
+  "component": true,
+  "usingComponents": {
+    "van-picker": "../picker/index"
+  }
+}

litemall-wx/lib/vant-weapp/datetime-picker/index.wxml

+<van-picker
+  class="van-datetime-picker"
+  active-class="active-class"
+  toolbar-class="toolbar-class"
+  column-class="column-class"
+  title="{{ title }}"
+  columns="{{ columns }}"
+  item-height="{{ itemHeight }}"
+  show-toolbar="{{ showToolbar }}"
+  visible-item-count="{{ visibleItemCount }}"
+  confirm-button-text="{{ confirmButtonText }}"
+  cancel-button-text="{{ cancelButtonText }}"
+  bind:change="onChange"
+  bind:confirm="onConfirm"
+  bind:cancel="onCancel"
+/>

litemall-wx/lib/vant-weapp/datetime-picker/index.wxss

+@import '../common/index.wxss';
\ No newline at end of file

litemall-wx/lib/vant-weapp/definitions/index.d.ts

+/// <reference types="miniprogram-api-typings" />
+import { Weapp } from './weapp';
+declare type RecordToAny<T> = {
+    [K in keyof T]: any;
+};
+export declare type CombinedComponentInstance<Data, Props, Methods> = Methods & WechatMiniprogram.Component.TrivialInstance & Weapp.FormField & {
+    data: Data & RecordToAny<Props>;
+};
+export interface VantComponentOptions<Data, Props, Methods, Instance> {
+    data?: Data;
+    field?: boolean;
+    classes?: string[];
+    mixins?: string[];
+    props?: Props & Weapp.PropertyOption;
+    watch?: Weapp.WatchOption<Instance>;
+    relation?: Weapp.RelationOption<Instance> & {
+        name: string;
+    };
+    relations?: {
+        [componentName: string]: Weapp.RelationOption<Instance>;
+    };
+    methods?: Methods & Weapp.MethodOption<Instance>;
+    beforeCreate?: (this: Instance) => void;
+    created?: (this: Instance) => void;
+    mounted?: (this: Instance) => void;
+    destroyed?: (this: Instance) => void;
+}
+export {};

litemall-wx/lib/vant-weapp/definitions/weapp.d.ts

+/// <reference types="miniprogram-api-typings" />
+export declare namespace Weapp {
+    export interface FormField {
+        data: {
+            name: string;
+            value: any;
+        };
+    }
+    interface Target {
+        id: string;
+        tagName: string;
+        dataset: {
+            [key: string]: any;
+        };
+    }
+    export interface Event {
+        /**
+         * 代表事件的类型。
+         */
+        type: string;
+        /**
+         * 页面打开到触发事件所经过的毫秒数。
+         */
+        timeStamp: number;
+        /**
+         * 触发事件的源组件。
+         */
+        target: Target;
+        /**
+         * 事件绑定的当前组件。
+         */
+        currentTarget: Target;
+        /**
+         * 额外的信息
+         */
+        detail: any;
+    }
+    interface Touch {
+        /**
+         * 触摸点的标识符
+         */
+        identifier: number;
+        /**
+         * 距离文档左上角的距离，文档的左上角为原点 ，横向为X轴，纵向为Y轴
+         */
+        pageX: number;
+        /**
+         * 距离文档左上角的距离，文档的左上角为原点 ，横向为X轴，纵向为Y轴
+         */
+        pageY: number;
+        /**
+         * 距离页面可显示区域（屏幕除去导航条）左上角距离，横向为X轴，纵向为Y轴
+         */
+        clientX: number;
+        /**
+         * 距离页面可显示区域（屏幕除去导航条）左上角距离，横向为X轴，纵向为Y轴
+         */
+        clientY: number;
+    }
+    export interface TouchEvent extends Event {
+        touches: Array<Touch>;
+        changedTouches: Array<Touch>;
+    }
+    /**
+     * relation定义，miniprogram-api-typings缺少this定义
+     */
+    export interface RelationOption<Instance> {
+        /** 目标组件的相对关系 */
+        type: 'parent' | 'child' | 'ancestor' | 'descendant';
+        /** 关系生命周期函数，当关系被建立在页面节点树中时触发，触发时机在组件attached生命周期之后 */
+        linked?(this: Instance, target: WechatMiniprogram.Component.TrivialInstance): void;
+        /** 关系生命周期函数，当关系在页面节点树中发生改变时触发，触发时机在组件moved生命周期之后 */
+        linkChanged?(this: Instance, target: WechatMiniprogram.Component.TrivialInstance): void;
+        /** 关系生命周期函数，当关系脱离页面节点树时触发，触发时机在组件detached生命周期之后 */
+        unlinked?(this: Instance, target: WechatMiniprogram.Component.TrivialInstance): void;
+        /** 如果这一项被设置，则它表示关联的目标节点所应具有的behavior，所有拥有这一behavior的组件节点都会被关联 */
+        target?: string;
+    }
+    /**
+     * obverser定义，miniprogram-api-typings缺少this定义
+     */
+    type Observer<Instance, T> = (this: Instance, newVal: T, oldVal: T, changedPath: Array<string | number>) => void;
+    /**
+     * watch定义
+     */
+    export interface WatchOption<Instance> {
+        [name: string]: string | Observer<Instance, any>;
+    }
+    /**
+     * methods定义，miniprogram-api-typings缺少this定义
+     */
+    export interface MethodOption<Instance> {
+        [name: string]: (this: Instance, ...args: any[]) => any;
+    }
+    export interface ComputedOption<Instance> {
+        [name: string]: (this: Instance) => any;
+    }
+    type PropertyType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor | FunctionConstructor | null;
+    export interface PropertyOption {
+        [name: string]: PropertyType | PropertyType[] | {
+            /** 属性类型 */
+            type: PropertyType | PropertyType[];
+            /** 属性初始值 */
+            value?: any;
+            /** 属性值被更改时的响应函数 */
+            observer?: string | Observer<WechatMiniprogram.Component.TrivialInstance, any>;
+            /** 属性的类型（可以指定多个） */
+            optionalTypes?: PropertyType[];
+        };
+    }
+    export {};
+}

litemall-wx/lib/vant-weapp/dialog/dialog.d.ts

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

litemall-wx/lib/vant-weapp/dialog/dialog.js

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

litemall-wx/lib/vant-weapp/dialog/index.d.ts

+export {};

litemall-wx/lib/vant-weapp/dialog/index.js

+import { VantComponent } from '../common/component';
+import { button } from '../mixins/button';
+import { openType } from '../mixins/open-type';
+import { addUnit } from '../common/utils';
+import { GRAY, BLUE } from '../common/color';
+VantComponent({
+    mixins: [button, openType],
+    props: {
+        show: Boolean,
+        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: {
+            type: null,
+            observer: 'setWidthWithUnit'
+        },
+        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
+        }
+    },
+    watch: {
+        show(show) {
+            !show && this.stopLoading();
+        }
+    },
+    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: {
+                    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);
+            }
+        },
+        setWidthWithUnit(val) {
+            this.setData({
+                widthWithUnit: addUnit(val)
+            });
+        }
+    }
+});

litemall-wx/lib/vant-weapp/dialog/index.json

+{
+  "component": true,
+  "usingComponents": {
+    "van-popup": "../popup/index",
+    "van-button": "../button/index"
+  }
+}

litemall-wx/lib/vant-weapp/dialog/index.wxml

+<van-popup
+  show="{{ show }}"
+  z-index="{{ zIndex }}"
+  overlay="{{ overlay }}"
+  transition="{{ transition }}"
+  custom-class="van-dialog {{ className }}"
+  custom-style="{{ widthWithUnit ? 'width: ' + widthWithUnit + ';' : '' }}{{ customStyle }}"
+  overlay-style="{{ overlayStyle }}"
+  close-on-click-overlay="{{ closeOnClickOverlay }}"
+  bind:close="onClickOverlay"
+>
+  <view
+    wx:if="{{ title || useTitleSlot  }}"
+    class="van-dialog__header {{ message || useSlot ? '' : 'van-dialog--isolated' }}"
+  >
+    <slot wx:if="{{ useTitleSlot }}" name="title" />
+    <block wx:elif="{{ title }}"> {{ title }}</block>
+  </view>
+
+  <slot wx:if="{{ useSlot }}" />
+  <view
+    wx:elif="{{ message }}"
+    class="van-dialog__message {{ title ? 'van-dialog__message--has-title' : '' }} {{ messageAlign ? 'van-dialog__message--' + messageAlign : '' }}"
+  >
+    <text class="van-dialog__message-text">{{ message }}</text>
+  </view>
+
+  <view class="van-hairline--top van-dialog__footer">
+    <van-button
+      wx:if="{{ showCancelButton }}"
+      size="large"
+      loading="{{ loading.cancel }}"
+      class="van-dialog__button van-hairline--right"
+      custom-class="van-dialog__cancel"
+      custom-style="color: {{ cancelButtonColor }}"
+      bind:click="onCancel"
+    >
+      {{ cancelButtonText }}
+    </van-button>
+    <van-button
+      wx:if="{{ showConfirmButton }}"
+      size="large"
+      class="van-dialog__button"
+      loading="{{ loading.confirm }}"
+      custom-class="van-dialog__confirm"
+      custom-style="color: {{ confirmButtonColor }}"
+
+      open-type="{{ confirmButtonOpenType }}"
+      lang="{{ lang }}"
+      business-id="{{ businessId }}"
+      session-from="{{ sessionFrom }}"
+      send-message-title="{{ sendMessageTitle }}"
+      send-message-path="{{ sendMessagePath }}"
+      send-message-img="{{ sendMessageImg }}"
+      show-message-card="{{ showMessageCard }}"
+      app-parameter="{{ appParameter }}"
+
+      bind:click="onConfirm"
+      bindgetuserinfo="bindGetUserInfo"
+      bindcontact="bindContact"
+      bindgetphonenumber="bindGetPhoneNumber"
+      binderror="bindError"
+      bindlaunchapp="bindLaunchApp"
+      bindopensetting="bindOpenSetting"
+    >
+      {{ confirmButtonText }}
+    </van-button>
+  </view>
+</van-popup>

litemall-wx/lib/vant-weapp/dialog/index.wxss

+@import '../common/index.wxss';.van-dialog{top:45%!important;overflow:hidden;width:320px;width:var(--dialog-width,320px);font-size:16px;font-size:var(--dialog-font-size,16px);border-radius:16px;border-radius:var(--dialog-border-radius,16px);background-color:#fff;background-color:var(--dialog-background-color,#fff)}@media (max-width:321px){.van-dialog{width:90%;width:var(--dialog-small-screen-width,90%)}}.van-dialog__header{text-align:center;padding-top:24px;padding-top:var(--dialog-header-padding-top,24px);font-weight:500;font-weight:var(--dialog-header-font-weight,500);line-height:24px;line-height:var(--dialog-header-line-height,24px)}.van-dialog__header--isolated{padding:24px 0;padding:var(--dialog-header-isolated-padding,24px 0)}.van-dialog__message{overflow-y:auto;text-align:center;-webkit-overflow-scrolling:touch;font-size:14px;font-size:var(--dialog-message-font-size,14px);line-height:20px;line-height:var(--dialog-message-line-height,20px);max-height:60vh;max-height:var(--dialog-message-max-height,60vh);padding:24px;padding:var(--dialog-message-padding,24px)}.van-dialog__message-text{word-wrap:break-word}.van-dialog__message--has-title{padding-top:12px;padding-top:var(--dialog-has-title-message-padding-top,12px);color:#646566;color:var(--dialog-has-title-message-text-color,#646566)}.van-dialog__message--left{text-align:left}.van-dialog__message--right{text-align:right}.van-dialog__footer{display:-webkit-flex;display:flex}.van-dialog__button{-webkit-flex:1;flex:1}.van-dialog__cancel,.van-dialog__confirm{border:0!important}.van-dialog-bounce-enter{-webkit-transform:translate3d(-50%,-50%,0) scale(.7);transform:translate3d(-50%,-50%,0) scale(.7);opacity:0}.van-dialog-bounce-leave-active{-webkit-transform:translate3d(-50%,-50%,0) scale(.9);transform:translate3d(-50%,-50%,0) scale(.9);opacity:0}
\ No newline at end of file

litemall-wx/lib/vant-weapp/divider/index.d.ts

+export {};

litemall-wx/lib/vant-weapp/divider/index.js

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