首次导入

litemall-wx/app.js

@@ -0,0 +1,42 @@
var util = require('./utils/util.js');
var api = require('./config/api.js');
var user = require('./utils/user.js');
App({
  onLaunch: function() {
    Promise.prototype.finally = function(callback){
      let P = this.constructor;
      return this.then(
              value => {
                   P.resolve(callback()).then(() => value)
               },
               reason => {
                   P.resolve(callback()).then(() => { throw reason })
               }
           )
    }
    const updateManager = wx.getUpdateManager();
    wx.getUpdateManager().onUpdateReady(function() {
      wx.showModal({
        title: '更新提示',
        content: '新版本已经准备好，是否重启应用？',
        success: function(res) {
          if (res.confirm) {
            // 新的版本已经下载好，调用 applyUpdate 应用新版本并重启
            updateManager.applyUpdate()
          }
        }
      })
    })
  },
  onShow: function(options) {
    user.checkLogin().then(res => {
      this.globalData.hasLogin = true;
    }).catch(() => {
      this.globalData.hasLogin = false;
    });
  },
  globalData: {
    hasLogin: false
  }
})

litemall-wx/app.json

@@ -0,0 +1,106 @@
{
  "pages": [
    "pages/index/index",
    "pages/catalog/catalog",
    "pages/newGoods/newGoods",
    "pages/hotGoods/hotGoods",
    "pages/ucenter/index/index",
    "pages/ucenter/address/address",
    "pages/ucenter/addressAdd/addressAdd",
    "pages/ucenter/feedback/feedback",
    "pages/ucenter/footprint/footprint",
    "pages/ucenter/order/order",
    "pages/ucenter/orderDetail/orderDetail",
    "pages/ucenter/couponList/couponList",
    "pages/ucenter/couponSelect/couponSelect",
    "pages/ucenter/collect/collect",
    "pages/auth/login/login",
    "pages/auth/accountLogin/accountLogin",
    "pages/auth/register/register",
    "pages/auth/reset/reset",
    "pages/payResult/payResult",
    "pages/comment/comment",
    "pages/commentPost/commentPost",
    "pages/topic/topic",
    "pages/topicComment/topicComment",
    "pages/topicDetail/topicDetail",
    "pages/topicCommentPost/topicCommentPost",
    "pages/brand/brand",
    "pages/brandDetail/brandDetail",
    "pages/search/search",
    "pages/category/category",
    "pages/cart/cart",
    "pages/checkout/checkout",
    "pages/goods/goods",
    "pages/about/about",
    "pages/groupon/myGroupon/myGroupon",
    "pages/groupon/grouponDetail/grouponDetail",
    "pages/groupon/grouponList/grouponList",
    "pages/coupon/coupon",
    "pages/help/help",
    "pages/ucenter/aftersale/aftersale",
    "pages/ucenter/aftersaleList/aftersaleList",
    "pages/ucenter/aftersaleDetail/aftersaleDetail"
  ],
  "window": {
    "navigationBarBackgroundColor": "#FFFFFF",
    "navigationBarTitleText": "litemall小程序商城",
    "enablePullDownRefresh": false,
    "navigationBarTextStyle": "black",
    "backgroundColor": "#FFFFFF",
    "backgroundTextStyle": "dark"
  },
  "tabBar": {
    "backgroundColor": "#fafafa",
    "borderStyle": "white",
    "selectedColor": "#AB956D",
    "color": "#666",
    "list": [
      {
        "pagePath": "pages/index/index",
        "iconPath": "static/images/home.png",
        "selectedIconPath": "static/images/home@selected.png",
        "text": "首页"
      },
      {
        "pagePath": "pages/catalog/catalog",
        "iconPath": "static/images/category.png",
        "selectedIconPath": "static/images/category@selected.png",
        "text": "分类"
      },
      {
        "pagePath": "pages/cart/cart",
        "iconPath": "static/images/cart.png",
        "selectedIconPath": "static/images/cart@selected.png",
        "text": "购物车"
      },
      {
        "pagePath": "pages/ucenter/index/index",
        "iconPath": "static/images/my.png",
        "selectedIconPath": "static/images/my@selected.png",
        "text": "个人"
      }
    ]
  },
  "networkTimeout": {
    "request": 10000,
    "connectSocket": 10000,
    "uploadFile": 10000,
    "downloadFile": 10000
  },
  "debug": true,
  "usingComponents": {
    "van-cell": "./lib/vant-weapp/cell/index",
    "van-cell-group": "./lib/vant-weapp/cell-group/index",
    "van-picker": "./lib/vant-weapp/picker/index",
    "van-popup": "./lib/vant-weapp/popup/index",
    "van-field": "./lib/vant-weapp/field/index",
    "van-uploader": "./lib/vant-weapp/uploader/index",
    "van-button": "./lib/vant-weapp/button/index",
    "van-tag": "./lib/vant-weapp/tag/index",
    "van-icon": "./lib/vant-weapp/icon/index",
    "van-checkbox": "./lib/vant-weapp/checkbox/index",
    "van-steps": "./lib/vant-weapp/steps/index"
  },
  "sitemapLocation": "sitemap.json"
}

litemall-wx/app.wxss

@@ -0,0 +1,19 @@
/**app.wxss**/
.container {
  box-sizing: border-box;
  background-color: #f4f4f4;
  font-family: PingFangSC-Light, helvetica, 'Heiti SC';
}
view, image, text, navigator {
  box-sizing: border-box;
  padding: 0;
  margin: 0;
}
view, text {
  font-family: PingFangSC-Light, helvetica, 'Heiti SC';
  font-size: 29rpx;
  color: #333;
}

litemall-wx/config/api.js

@@ -0,0 +1,103 @@
// 以下是业务服务器API地址
// 本机开发时使用
var WxApiRoot = 'http://localhost:8080/wx/';
// 局域网测试使用
// var WxApiRoot = 'http://192.168.1.3:8080/wx/';
// 云平台部署时使用
// var WxApiRoot = 'http://122.51.199.160:8080/wx/';
// 云平台上线时使用
// var WxApiRoot = 'https://www.menethil.com.cn/wx/';
module.exports = {
  IndexUrl: WxApiRoot + 'home/index', //首页数据接口
  AboutUrl: WxApiRoot + 'home/about', //介绍信息
  CatalogList: WxApiRoot + 'catalog/index', //分类目录全部分类数据接口
  CatalogCurrent: WxApiRoot + 'catalog/current', //分类目录当前分类数据接口
  AuthLoginByWeixin: WxApiRoot + 'auth/login_by_weixin', //微信登录
  AuthLoginByAccount: WxApiRoot + 'auth/login', //账号登录
  AuthLogout: WxApiRoot + 'auth/logout', //账号登出
  AuthRegister: WxApiRoot + 'auth/register', //账号注册
  AuthReset: WxApiRoot + 'auth/reset', //账号密码重置
  AuthRegisterCaptcha: WxApiRoot + 'auth/regCaptcha', //验证码
  AuthBindPhone: WxApiRoot + 'auth/bindPhone', //绑定微信手机号
  GoodsCount: WxApiRoot + 'goods/count', //统计商品总数
  GoodsList: WxApiRoot + 'goods/list', //获得商品列表
  GoodsCategory: WxApiRoot + 'goods/category', //获得分类数据
  GoodsDetail: WxApiRoot + 'goods/detail', //获得商品的详情
  GoodsRelated: WxApiRoot + 'goods/related', //商品详情页的关联商品（大家都在看）
  BrandList: WxApiRoot + 'brand/list', //品牌列表
  BrandDetail: WxApiRoot + 'brand/detail', //品牌详情
  CartList: WxApiRoot + 'cart/index', //获取购物车的数据
  CartAdd: WxApiRoot + 'cart/add', // 添加商品到购物车
  CartFastAdd: WxApiRoot + 'cart/fastadd', // 立即购买商品
  CartUpdate: WxApiRoot + 'cart/update', // 更新购物车的商品
  CartDelete: WxApiRoot + 'cart/delete', // 删除购物车的商品
  CartChecked: WxApiRoot + 'cart/checked', // 选择或取消选择商品
  CartGoodsCount: WxApiRoot + 'cart/goodscount', // 获取购物车商品件数
  CartCheckout: WxApiRoot + 'cart/checkout', // 下单前信息确认
  CollectList: WxApiRoot + 'collect/list', //收藏列表
  CollectAddOrDelete: WxApiRoot + 'collect/addordelete', //添加或取消收藏
  CommentList: WxApiRoot + 'comment/list', //评论列表
  CommentCount: WxApiRoot + 'comment/count', //评论总数
  CommentPost: WxApiRoot + 'comment/post', //发表评论
  TopicList: WxApiRoot + 'topic/list', //专题列表
  TopicDetail: WxApiRoot + 'topic/detail', //专题详情
  TopicRelated: WxApiRoot + 'topic/related', //相关专题
  SearchIndex: WxApiRoot + 'search/index', //搜索关键字
  SearchResult: WxApiRoot + 'search/result', //搜索结果
  SearchHelper: WxApiRoot + 'search/helper', //搜索帮助
  SearchClearHistory: WxApiRoot + 'search/clearhistory', //搜索历史清楚
  AddressList: WxApiRoot + 'address/list', //收货地址列表
  AddressDetail: WxApiRoot + 'address/detail', //收货地址详情
  AddressSave: WxApiRoot + 'address/save', //保存收货地址
  AddressDelete: WxApiRoot + 'address/delete', //保存收货地址
  ExpressQuery: WxApiRoot + 'express/query', //物流查询
  RegionList: WxApiRoot + 'region/list', //获取区域列表
  OrderSubmit: WxApiRoot + 'order/submit', // 提交订单
  OrderPrepay: WxApiRoot + 'order/prepay', // 订单的预支付会话
  OrderList: WxApiRoot + 'order/list', //订单列表
  OrderDetail: WxApiRoot + 'order/detail', //订单详情
  OrderCancel: WxApiRoot + 'order/cancel', //取消订单
  OrderRefund: WxApiRoot + 'order/refund', //退款取消订单
  OrderDelete: WxApiRoot + 'order/delete', //删除订单
  OrderConfirm: WxApiRoot + 'order/confirm', //确认收货
  OrderGoods: WxApiRoot + 'order/goods', // 代评价商品信息
  OrderComment: WxApiRoot + 'order/comment', // 评价订单商品信息
  AftersaleSubmit: WxApiRoot + 'aftersale/submit', // 提交售后申请
  AftersaleList: WxApiRoot + 'aftersale/list', // 售后列表
  AftersaleDetail: WxApiRoot + 'aftersale/detail', // 售后详情
  FeedbackAdd: WxApiRoot + 'feedback/submit', //添加反馈
  FootprintList: WxApiRoot + 'footprint/list', //足迹列表
  FootprintDelete: WxApiRoot + 'footprint/delete', //删除足迹
  GroupOnList: WxApiRoot + 'groupon/list', //团购列表
  GroupOnMy: WxApiRoot + 'groupon/my', //团购API-我的团购
  GroupOnDetail: WxApiRoot + 'groupon/detail', //团购API-详情
  GroupOnJoin: WxApiRoot + 'groupon/join', //团购API-详情
  CouponList: WxApiRoot + 'coupon/list', //优惠券列表
  CouponMyList: WxApiRoot + 'coupon/mylist', //我的优惠券列表
  CouponSelectList: WxApiRoot + 'coupon/selectlist', //当前订单可用优惠券列表
  CouponReceive: WxApiRoot + 'coupon/receive', //优惠券领取
  CouponExchange: WxApiRoot + 'coupon/exchange', //优惠券兑换
  StorageUpload: WxApiRoot + 'storage/upload', //图片上传,
  UserIndex: WxApiRoot + 'user/index', //个人页面用户相关信息
  IssueList: WxApiRoot + 'issue/list', //帮助信息
};

litemall-wx/lib/vant-weapp/action-sheet/index.d.ts

@@ -0,0 +1 @@
export {};

litemall-wx/lib/vant-weapp/action-sheet/index.js

@@ -0,0 +1,59 @@
import { VantComponent } from '../common/component';
VantComponent({
    props: {
        show: Boolean,
        title: String,
        cancelText: String,
        description: String,
        round: {
            type: Boolean,
            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: {
        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();
        }
    }
});

litemall-wx/lib/vant-weapp/action-sheet/index.json

@@ -0,0 +1,8 @@
{
  "component": true,
  "usingComponents": {
    "van-icon": "../icon/index",
    "van-popup": "../popup/index",
    "van-loading": "../loading/index"
  }
}

litemall-wx/lib/vant-weapp/action-sheet/index.wxml

@@ -0,0 +1,54 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<van-popup
  show="{{ show }}"
  position="bottom"
  round="{{ round }}"
  z-index="{{ zIndex }}"
  overlay="{{ overlay }}"
  custom-class="van-action-sheet"
  safe-area-inset-bottom="{{ safeAreaInsetBottom }}"
  close-on-click-overlay="{{ closeOnClickOverlay }}"
  bind:close="onClickOverlay"
>
  <view wx:if="{{ title }}" class="van-hairline--bottom van-action-sheet__header">
    {{ title }}
    <van-icon
      name="close"
      custom-class="van-action-sheet__close"
      bind:click="onClose"
    />
  </view>
  <view wx:if="{{ description }}" class="van-action-sheet__description">
    {{ description }}
  </view>
  <view wx:if="{{ actions && actions.length }}">
    <!-- button外包一层view，防止actions动态变化，导致渲染时button被打散 -->
    <button
      wx:for="{{ actions }}"
      wx:key="index"
      open-type="{{ item.openType }}"
      style="{{ item.color ? 'color: ' + item.color : '' }}"
      class="{{ utils.bem('action-sheet__item', { disabled: item.disabled || item.loading }) }} van-hairline--top {{ item.className || '' }}"
      hover-class="van-action-sheet__item--hover"
      data-index="{{ index }}"
      bind:tap="onSelect"
    >
      <block wx:if="{{ !item.loading }}">
        {{ item.name }}
        <text wx:if="{{ item.subname }}" class="van-action-sheet__subname" >{{ item.subname }}</text>
      </block>
      <van-loading wx:else custom-class="van-action-sheet__loading" size="20px" />
    </button>
  </view>
  <slot />
  <view
    wx:if="{{ cancelText }}"
    class="van-action-sheet__cancel"
    hover-class="van-action-sheet__cancel--hover"
    hover-stay-time="70"
    bind:tap="onCancel"
  >
    {{ cancelText }}
  </view>
</van-popup>

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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,210 @@
import { VantComponent } from '../common/component';
import { pickerProps } from '../picker/shared';
const COLUMNSPLACEHOLDERCODE = '000000';
VantComponent({
    classes: ['active-class', 'toolbar-class', 'column-class'],
    props: Object.assign(Object.assign({}, pickerProps), { value: String, areaList: {
            type: Object,
            value: {}
        }, columnsNum: {
            type: null,
            value: 3
        }, columnsPlaceholder: {
            type: Array,
            observer(val) {
                this.setData({
                    typeToColumnsPlaceholder: {
                        province: val[0] || '',
                        city: val[1] || '',
                        county: val[2] || '',
                    }
                });
            }
        } }),
    data: {
        columns: [{ values: [] }, { values: [] }, { values: [] }],
        displayColumns: [{ values: [] }, { values: [] }, { values: [] }],
        typeToColumnsPlaceholder: {}
    },
    watch: {
        value(value) {
            this.code = value;
            this.setValues();
        },
        areaList: 'setValues',
        columnsNum(value) {
            this.setData({
                displayColumns: this.data.columns.slice(0, +value)
            });
        }
    },
    mounted() {
        setTimeout(() => {
            this.setValues();
        }, 0);
    },
    methods: {
        getPicker() {
            if (this.picker == null) {
                this.picker = this.selectComponent('.van-area__picker');
            }
            return this.picker;
        },
        onCancel(event) {
            this.emit('cancel', event.detail);
        },
        onConfirm(event) {
            const { index } = event.detail;
            let { value } = event.detail;
            value = this.parseOutputValues(value);
            this.emit('confirm', { value, index });
        },
        emit(type, detail) {
            detail.values = detail.value;
            delete detail.value;
            this.$emit(type, detail);
        },
        // parse output columns data
        parseOutputValues(values) {
            const { columnsPlaceholder } = this.data;
            return values.map((value, index) => {
                // save undefined value
                if (!value)
                    return value;
                value = JSON.parse(JSON.stringify(value));
                if (!value.code || value.name === columnsPlaceholder[index]) {
                    value.code = '';
                    value.name = '';
                }
                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();
        }
    }
});

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

@@ -0,0 +1,6 @@
{
  "component": true,
  "usingComponents": {
    "van-picker": "../picker/index"
  }
}

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

@@ -0,0 +1,18 @@
<van-picker
  class="van-area__picker"
  active-class="active-class"
  toolbar-class="toolbar-class"
  column-class="column-class"
  show-toolbar
  value-key="name"
  title="{{ title }}"
  loading="{{ loading }}"
  columns="{{ displayColumns }}"
  item-height="{{ itemHeight }}"
  visible-item-count="{{ visibleItemCount }}"
  cancel-button-text="{{ cancelButtonText }}"
  confirm-button-text="{{ confirmButtonText }}"
  bind:change="onChange"
  bind:confirm="onConfirm"
  bind:cancel="onCancel"
/>

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

@@ -0,0 +1 @@
@import '../common/index.wxss';

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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,68 @@
import { VantComponent } from '../common/component';
import { button } from '../mixins/button';
import { openType } from '../mixins/open-type';
VantComponent({
    mixins: [button, openType],
    classes: ['hover-class', 'loading-class'],
    data: {
        style: ''
    },
    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'
        },
        type: {
            type: String,
            value: 'default'
        },
        size: {
            type: String,
            value: 'normal'
        },
        loadingSize: {
            type: String,
            value: '20px'
        },
        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.style) {
                    this.setData({ style });
                }
            }
        }
    },
    methods: {
        onClick() {
            if (!this.data.disabled && !this.data.loading) {
                this.$emit('click');
            }
        }
    }
});

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

@@ -0,0 +1,7 @@
{
  "component": true,
  "usingComponents": {
    "van-icon": "../icon/index",
    "van-loading": "../loading/index"
  }
}

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

@@ -0,0 +1,52 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<button
  id="{{ id }}"
  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"
  lang="{{ lang }}"
  style="{{ style }} {{ customStyle }}"
  open-type="{{ openType }}"
  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 }}"
  aria-label="{{ ariaLabel }}"
  bindtap="onClick"
  bindgetuserinfo="bindGetUserInfo"
  bindcontact="bindContact"
  bindgetphonenumber="bindGetPhoneNumber"
  binderror="bindError"
  bindlaunchapp="bindLaunchApp"
  bindopensetting="bindOpenSetting"
>
  <block wx:if="{{ loading }}">
    <van-loading
      custom-class="loading-class"
      size="{{ loadingSize }}"
      type="{{ loadingType }}"
      color="{{ type === 'default' ? '#c9c9c9' : 'white' }}"
    />
    <view
      wx:if="{{ loadingText }}"
      class="van-button__loading-text"
    >
      {{ loadingText }}
    </view>
  </block>
  <block wx:else>
    <van-icon
      wx:if="{{ icon }}"
      size="1.2em"
      name="{{ icon }}"
      class="van-button__icon"
      custom-style="line-height: inherit;"
    />
    <view class="van-button__text">
      <slot />
    </view>
  </block>
</button>

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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,38 @@
import { link } from '../mixins/link';
import { VantComponent } from '../common/component';
VantComponent({
    classes: [
        'num-class',
        'desc-class',
        'thumb-class',
        'title-class',
        'price-class',
        'origin-price-class',
    ],
    mixins: [link],
    props: {
        tag: String,
        num: String,
        desc: String,
        thumb: String,
        title: String,
        price: String,
        centered: Boolean,
        lazyLoad: Boolean,
        thumbLink: String,
        originPrice: String,
        thumbMode: {
            type: String,
            value: 'aspectFit'
        },
        currency: {
            type: String,
            value: '¥'
        }
    },
    methods: {
        onClickThumb() {
            this.jumpLink('thumbLink');
        }
    }
});

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

@@ -0,0 +1,6 @@
{
  "component": true,
  "usingComponents": {
    "van-tag": "../tag/index"
  }
}

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

@@ -0,0 +1,45 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<view class="custom-class van-card">
  <view class="{{ utils.bem('card__header', { center: centered }) }}">
    <view class="van-card__thumb" bind:tap="onClickThumb">
      <image
        wx:if="{{ thumb }}"
        src="{{ thumb }}"
        mode="{{ thumbMode }}"
        lazy-load="{{ lazyLoad }}"
        class="van-card__img thumb-class"
      />
      <slot name="thumb" />
      <van-tag
        wx:if="{{ tag }}"
        mark
        type="danger"
        custom-class="van-card__tag"
      >
        {{ tag }}
      </van-tag>
    </view>
    <view class="van-card__content">
      <view wx:if="{{ title }}" class="van-card__title title-class">{{ title }}</view>
      <slot wx:else name="title" />
      <view wx:if="{{ desc }}" class="van-card__desc desc-class">{{ desc }}</view>
      <slot wx:else name="desc" />
      <slot name="tags" />
      <view class="van-card__bottom">
        <view wx:if="{{ price || price === 0 }}" class="van-card__price price-class">{{ currency }} {{ price }}</view>
        <view wx:if="{{ originPrice || originPrice === 0 }}" class="van-card__origin-price origin-price-class">{{ currency }} {{ originPrice }}</view>
        <view wx:if="{{ num }}" class="van-card__num num-class">x {{ num }}</view>
        <slot name="bottom" />
      </view>
    </view>
  </view>
  <view class="van-card__footer">
    <slot name="footer" />
  </view>
</view>

litemall-wx/lib/vant-weapp/cell-group/index.d.ts

@@ -0,0 +1 @@
export {};

litemall-wx/lib/vant-weapp/cell-group/index.js

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

litemall-wx/lib/vant-weapp/cell-group/index.json

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

litemall-wx/lib/vant-weapp/cell-group/index.wxml

@@ -0,0 +1,9 @@
<view
  wx:if="{{ title }}"
  class="van-cell-group__title"
>
  {{ title }}
</view>
<view class="custom-class van-cell-group {{ border ? 'van-hairline--top-bottom' : '' }}">
  <slot />
</view>

litemall-wx/lib/vant-weapp/cell-group/index.wxss

@@ -0,0 +1 @@
@import '../common/index.wxss';.van-cell-group__title{padding:16px 16px 8px;padding:var(--cell-group-title-padding,16px 16px 8px);font-size:14px;font-size:var(--cell-group-title-font-size,14px);line-height:16px;line-height:var(--cell-group-title-line-height,16px);color:#969799;color:var(--cell-group-title-color,#969799)}

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

@@ -0,0 +1 @@
export {};

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

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

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

@@ -0,0 +1,6 @@
{
  "component": true,
  "usingComponents": {
    "van-icon": "../icon/index"
  }
}

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

@@ -0,0 +1,45 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<view
  class="custom-class {{ utils.bem('cell', [size, { center, required, borderless: !border, clickable: isLink || clickable }]) }}"
  hover-class="van-cell--hover hover-class"
  hover-stay-time="70"
  style="{{ customStyle }}"
  bind:tap="onClick"
>
  <van-icon
    wx:if="{{ icon }}"
    name="{{ icon }}"
    class="van-cell__left-icon-wrap"
    custom-class="van-cell__left-icon"
  />
  <slot wx:else name="icon" />
  <view
    style="{{ titleWidth ? 'max-width:' + titleWidth + ';min-width:' + titleWidth : '' }}"
    class="van-cell__title title-class"
  >
    <block wx:if="{{ title }}">{{ title }}</block>
    <slot wx:else name="title" />
    <view wx:if="{{ label || useLabelSlot }}" class="van-cell__label label-class">
      <slot wx:if="{{ useLabelSlot }}" name="label" />
      <block wx:elif="{{ label }}">{{ label }}</block>
    </view>
  </view>
  <view class="van-cell__value value-class">
    <block wx:if="{{ value || value === 0 }}">{{ value }}</block>
    <slot wx:else />
  </view>
  <van-icon
    wx:if="{{ isLink }}"
    name="{{ arrowDirection ? 'arrow' + '-' + arrowDirection : 'arrow' }}"
    class="van-cell__right-icon-wrap right-icon-class"
    custom-class="van-cell__right-icon"
  />
  <slot wx:else name="right-icon" />
  <slot name="extra" />
</view>

litemall-wx/lib/vant-weapp/checkbox-group/index.d.ts

@@ -0,0 +1 @@
export {};

litemall-wx/lib/vant-weapp/checkbox-group/index.js

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

litemall-wx/lib/vant-weapp/checkbox-group/index.json

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

litemall-wx/lib/vant-weapp/checkbox-group/index.wxml

@@ -0,0 +1 @@
<slot />

litemall-wx/lib/vant-weapp/checkbox-group/index.wxss

@@ -0,0 +1 @@
@import '../common/index.wxss';

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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,87 @@
import { VantComponent } from '../common/component';
import { addUnit } from '../common/utils';
function emit(target, value) {
    target.$emit('input', value);
    target.$emit('change', value);
}
VantComponent({
    field: true,
    relation: {
        name: 'checkbox-group',
        type: 'ancestor',
        linked(target) {
            this.parent = target;
        },
        unlinked() {
            this.parent = null;
        }
    },
    classes: ['icon-class', 'label-class'],
    props: {
        value: Boolean,
        disabled: Boolean,
        useIconSlot: Boolean,
        checkedColor: String,
        labelPosition: String,
        labelDisabled: Boolean,
        shape: {
            type: String,
            value: 'round'
        },
        iconSize: {
            type: null,
            observer: 'setSizeWithUnit'
        }
    },
    data: {
        sizeWithUnit: '20px'
    },
    methods: {
        emitChange(value) {
            if (this.parent) {
                this.setParentValue(this.parent, value);
            }
            else {
                emit(this, value);
            }
        },
        toggle() {
            const { disabled, value } = this.data;
            if (!disabled) {
                this.emitChange(!value);
            }
        },
        onClickLabel() {
            const { labelDisabled, disabled, value } = this.data;
            if (!disabled && !labelDisabled) {
                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);
                }
            }
        },
        setSizeWithUnit(size) {
            this.set({
                sizeWithUnit: addUnit(size)
            });
        },
    }
});

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

@@ -0,0 +1,6 @@
{
  "component": true,
  "usingComponents": {
    "van-icon": "../icon/index"
  }
}

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

@@ -0,0 +1,19 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<view class="van-checkbox custom-class">
  <view class="van-checkbox__icon-wrap" bindtap="toggle">
    <slot wx:if="{{ useIconSlot }}" name="icon" />
    <van-icon
      wx:else
      name="success"
      size="0.8em"
      class="{{ utils.bem('checkbox__icon', [shape, { disabled, checked: value }]) }}"
      style="font-size: {{ sizeWithUnit }};{{ checkedColor && value && !disabled ? 'border-color:' + checkedColor + '; background-color:' + checkedColor : '' }}"
      custom-class="icon-class"
      custom-style="line-height: 1.25em;"
    />
  </view>
  <view class="label-class {{ utils.bem('checkbox__label', [labelPosition, { disabled }]) }}" bindtap="onClickLabel">
    <slot />
  </view>
</view>

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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,158 @@
import { VantComponent } from '../common/component';
import { isObj } from '../common/utils';
import { BLUE, WHITE } from '../common/color';
function format(rate) {
    return Math.min(Math.max(rate, 0), 100);
}
const PERIMETER = 2 * Math.PI;
const BEGIN_ANGLE = -Math.PI / 2;
const STEP = 1;
VantComponent({
    props: {
        text: String,
        lineCap: {
            type: String,
            value: 'round'
        },
        value: {
            type: Number,
            value: 0,
            observer: 'reRender'
        },
        speed: {
            type: Number,
            value: 50
        },
        size: {
            type: Number,
            value: 100,
            observer: 'setStyle'
        },
        fill: String,
        layerColor: {
            type: String,
            value: WHITE
        },
        color: {
            type: [String, Object],
            value: BLUE,
            observer: 'setHoverColor'
        },
        strokeWidth: {
            type: Number,
            value: 4
        },
        clockwise: {
            type: Boolean,
            value: true
        }
    },
    data: {
        style: 'width: 100px; height: 100px;',
        hoverColor: BLUE
    },
    methods: {
        getContext() {
            if (!this.ctx) {
                this.ctx = wx.createCanvasContext('van-circle', this);
            }
            return this.ctx;
        },
        setHoverColor() {
            const context = this.getContext();
            const { color, size } = this.data;
            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 });
        },
        setStyle() {
            const { size } = this.data;
            const style = `width: ${size}px; height: ${size}px;`;
            this.setData({ style });
        },
        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 context = this.getContext();
            const { size } = this.data;
            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() {
        const { value } = this.data;
        this.currentValue = value;
        this.drawCircle(value);
    },
    destroyed() {
        this.ctx = null;
        this.clearInterval();
    }
});

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

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

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

@@ -0,0 +1,7 @@
<view class="van-circle">
  <canvas class="van-circle__canvas" style="{{ style }}" canvas-id="van-circle"></canvas>
  <view wx:if="{{ !text }}" class="van-circle__text">
    <slot></slot>
  </view>
  <cover-view wx:else class="van-circle__text">{{ text }}</cover-view>
</view>

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

@@ -0,0 +1 @@
@import '../common/index.wxss';.van-circle{position:relative;display:inline-block;text-align:center}.van-circle__text{position:absolute;top:50%;left:0;width:100%;-webkit-transform:translateY(-50%);transform:translateY(-50%);color:#323233;color:var(--circle-text-color,#323233)}

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

@@ -0,0 +1 @@
export {};

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

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

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

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

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

@@ -0,0 +1,8 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<view
  class="custom-class {{ utils.bem('col', [span]) }} {{ offset ? 'van-col--offset-' + offset : '' }}"
  style="{{ style }}"
>
  <slot />
</view>

litemall-wx/lib/vant-weapp/collapse-item/index.d.ts

@@ -0,0 +1 @@
export {};

litemall-wx/lib/vant-weapp/collapse-item/index.js

@@ -0,0 +1,96 @@
import { VantComponent } from '../common/component';
const nextTick = () => new Promise(resolve => setTimeout(resolve, 20));
VantComponent({
    classes: ['title-class', 'content-class'],
    relation: {
        name: 'collapse',
        type: 'ancestor',
        linked(parent) {
            this.parent = parent;
        }
    },
    props: {
        name: null,
        title: null,
        value: null,
        icon: String,
        label: String,
        disabled: Boolean,
        clickable: Boolean,
        border: {
            type: Boolean,
            value: true
        },
        isLink: {
            type: Boolean,
            value: true
        }
    },
    data: {
        contentHeight: 0,
        expanded: false,
        transition: false
    },
    mounted() {
        this.updateExpanded()
            .then(nextTick)
            .then(() => {
            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);
        },
        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'
                });
            }
        }
    }
});

litemall-wx/lib/vant-weapp/collapse-item/index.json

@@ -0,0 +1,6 @@
{
  "component": true,
  "usingComponents": {
    "van-cell": "../cell/index"
  }
}

litemall-wx/lib/vant-weapp/collapse-item/index.wxml

@@ -0,0 +1,44 @@
<wxs src="../wxs/utils.wxs" module="utils" />
<view class="van-collapse-item custom-class {{ index !== 0 ? 'van-hairline--top' : '' }}">
  <van-cell
    title="{{ title }}"
    title-class="title-class"
    icon="{{ icon }}"
    value="{{ value }}"
    label="{{ label }}"
    is-link="{{ isLink }}"
    clickable="{{ clickable }}"
    border="{{ border && expanded }}"
    class="{{ utils.bem('collapse-item__title', { disabled, expanded }) }}"
    right-icon-class="van-cell__right-icon"
    custom-class="van-cell"
    hover-class="van-cell--hover"
    bind:click="onClick"
  >
    <slot
      name="title"
      slot="title"
    />
    <slot
      name="icon"
      slot="icon"
    />
    <slot name="value" />
    <slot
      name="right-icon"
      slot="right-icon"
    />
  </van-cell>
  <view
    class="{{ utils.bem('collapse-item__wrapper', { transition }) }}"
    style="height: {{ contentHeight }};"
    bind:transitionend="onTransitionEnd"
  >
    <view
      class="van-collapse-item__content content-class"
    >
      <slot />
    </view>
  </view>
</view>

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

@@ -0,0 +1 @@
export {};

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

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

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

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

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

@@ -0,0 +1,3 @@
<view class="custom-class van-collapse {{ border ? 'van-hairline--top-bottom' : '' }}">
  <slot />
</view>

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

@@ -0,0 +1 @@
@import '../common/index.wxss';

litemall-wx/lib/vant-weapp/common/color.d.ts

@@ -0,0 +1,7 @@
export declare const RED = "#ee0a24";
export declare const BLUE = "#1989fa";
export declare const WHITE = "#fff";
export declare const GREEN = "#07c160";
export declare const ORANGE = "#ff976a";
export declare const GRAY = "#323233";
export declare const GRAY_DARK = "#969799";

litemall-wx/lib/vant-weapp/common/color.js

@@ -0,0 +1,7 @@
export const RED = '#ee0a24';
export const BLUE = '#1989fa';
export const WHITE = '#fff';
export const GREEN = '#07c160';
export const ORANGE = '#ff976a';
export const GRAY = '#323233';
export const GRAY_DARK = '#969799';

litemall-wx/lib/vant-weapp/common/component.d.ts

@@ -0,0 +1,3 @@
import { VantComponentOptions, CombinedComponentInstance } from '../definitions/index';
declare function VantComponent<Data, Props, Methods>(vantOptions?: VantComponentOptions<Data, Props, Methods, CombinedComponentInstance<Data, Props, Methods>>): void;
export { VantComponent };

litemall-wx/lib/vant-weapp/common/component.js

@@ -0,0 +1,48 @@
import { basic } from '../mixins/basic';
import { observe } from '../mixins/observer/index';
function mapKeys(source, target, map) {
    Object.keys(map).forEach(key => {
        if (source[key]) {
            target[map[key]] = source[key];
        }
    });
}
function VantComponent(vantOptions = {}) {
    const options = {};
    mapKeys(vantOptions, options, {
        data: 'data',
        props: 'properties',
        mixins: 'behaviors',
        methods: 'methods',
        beforeCreate: 'created',
        created: 'attached',
        mounted: 'ready',
        relations: 'relations',
        destroyed: 'detached',
        classes: 'externalClasses'
    });
    const { relation } = vantOptions;
    if (relation) {
        options.relations = Object.assign(options.relations || {}, {
            [`../${relation.name}/index`]: relation
        });
    }
    // add default externalClasses
    options.externalClasses = options.externalClasses || [];
    options.externalClasses.push('custom-class');
    // 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');
    }
    // add default options
    options.options = {
        multipleSlots: true,
        addGlobalClass: true
    };
    observe(vantOptions, options);
    Component(options);
}
export { VantComponent };

litemall-wx/lib/vant-weapp/common/style/clearfix.wxss

@@ -0,0 +1 @@
.van-clearfix:after{display:table;clear:both;content:""}

litemall-wx/lib/vant-weapp/common/style/ellipsis.wxss

@@ -0,0 +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}

litemall-wx/lib/vant-weapp/common/utils.d.ts

@@ -0,0 +1,8 @@
/// <reference types="miniprogram-api-typings" />
export declare function isDef(value: any): boolean;
export declare function isObj(x: any): boolean;
export declare function isNumber(value: any): boolean;
export declare function range(num: number, min: number, max: number): number;
export declare function nextTick(fn: Function): void;
export declare function getSystemInfoSync(): WechatMiniprogram.GetSystemInfoSuccessCallbackResult;
export declare function addUnit(value?: string | number): string | undefined;

litemall-wx/lib/vant-weapp/common/utils.js

@@ -0,0 +1,32 @@
export function isDef(value) {
    return value !== undefined && value !== null;
}
export function isObj(x) {
    const type = typeof x;
    return x !== null && (type === 'object' || type === 'function');
}
export function isNumber(value) {
    return /^\d+(\.\d+)?$/.test(value);
}
export function range(num, min, max) {
    return Math.min(Math.max(num, min), max);
}
export function nextTick(fn) {
    setTimeout(() => {
        fn();
    }, 1000 / 30);
}
let systemInfo = null;
export function getSystemInfoSync() {
    if (systemInfo == null) {
        systemInfo = wx.getSystemInfoSync();
    }
    return systemInfo;
}
export function addUnit(value) {
    if (!isDef(value)) {
        return undefined;
    }
    value = String(value);
    return isNumber(value) ? `${value}px` : value;
}

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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,100 @@
import { VantComponent } from '../common/component';
import { isSameSecond, parseFormat, parseTimeData } from './utils';
function simpleTick(fn) {
    return setTimeout(fn, 30);
}
VantComponent({
    props: {
        useSlot: Boolean,
        millisecond: Boolean,
        time: {
            type: Number,
            observer: 'reset'
        },
        format: {
            type: String,
            value: 'HH:mm:ss'
        },
        autoStart: {
            type: Boolean,
            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();
                }
            });
        },
        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');
            }
        }
    }
});

litemall-wx/lib/vant-weapp/count-down/index.json

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

litemall-wx/lib/vant-weapp/count-down/index.wxml

@@ -0,0 +1,4 @@
<view class="van-count-down">
  <slot wx:if="{{ useSlot }}"/>
  <block wx:else>{{ formattedTime }}</block>
</view>

litemall-wx/lib/vant-weapp/count-down/index.wxss

@@ -0,0 +1 @@
@import '../common/index.wxss';.van-count-down{color:#323233;color:var(--count-down-text-color,#323233);font-size:14px;font-size:var(--count-down-font-size,14px);line-height:20px;line-height:var(--count-down-line-height,20px)}

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

@@ -0,0 +1,10 @@
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

@@ -0,0 +1,57 @@
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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,297 @@
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

@@ -0,0 +1,6 @@
{
  "component": true,
  "usingComponents": {
    "van-picker": "../picker/index"
  }
}

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

@@ -0,0 +1,16 @@
<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

@@ -0,0 +1 @@
@import '../common/index.wxss';

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

@@ -0,0 +1,28 @@
/// <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

@@ -0,0 +1,112 @@
/// <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

@@ -0,0 +1,47 @@
/// <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

@@ -0,0 +1,63 @@
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

@@ -0,0 +1 @@
export {};

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

@@ -0,0 +1,119 @@
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)
            });
        }
    }
});