├── README.md
├── app.js
├── app.json
├── app.wxss
├── pages
├── .DS_Store
├── common
│ ├── image_uploader
│ │ ├── image_uploader.js
│ │ ├── image_uploader.wxml
│ │ └── image_uploader.wxss
│ └── lib
│ │ └── weui.wxss
└── upload_img_demo
│ ├── index.js
│ ├── index.json
│ ├── index.wxml
│ └── index.wxss
└── utils
├── bluebird.js
├── util.js
└── wechat.js
/README.md:
--------------------------------------------------------------------------------
1 | ## 小程序上传图片示例组件
2 |
3 | 这是一个上传图片示例组件，目的在于展示如何在小程序中编写组件，**请不要一点代码都不改直接拿来用于生产环境哦**。
4 |
5 | 组件的关键设计思路，请看[这篇文章](https://judes.me/tech/2017/02/11/wechat_app.html)
6 |
7 | ## 使用方法和注意事项
8 |
9 | - 因为本组件有大量 ES6 语法，请先勾选小程序开发工具中的“开启 ES6 转 ES5 ”选项
10 | - 先在页面的 wxml 文件中引入本组件模板，下面的代码实例化了两个组件实例。 `img1` 与 `img2` 分别是两个实例的 `key` ，请确保同一个页面中不同实例的 `key` 不一样 ：
11 | ```
12 |
13 |
14 |
15 |
16 |
17 |
18 | ```
19 |
20 | - 然后在页面的 js 文件中，先引入组件的类，定制各个组件的初始数据，然后实例化，与上面的代码对应的写法如下：
21 | ```
22 | //index.js
23 | const ImageUploader = require('../common/image_uploader/image_uploader.js');
24 | Page({
25 | data: {
26 | img1: ImageUploader.mergeData({
27 | imageUploadTitle: '定制标题1',//组件的标题
28 |
29 | sourceType: ['camera', 'album'], //上传图片的来源，相机/相册
30 | sizeType: ['compressed'],//上传前是否压缩，默认压缩
31 | maxCount: 1,//一次选择图片的数量
32 | //以上三个配置项详情请看小程序文档
33 |
34 | uploadedImagesPaths: [],//用数组保存已上传的图片路径，也可以设置初始时就显示的图片
35 | uploadParams: {
36 | url: '',//后台接收上传图片的路径
37 | name: 'file',//后台依靠这个字段拿到文件对象
38 | formData: {}//这个字段可以设置传到后台的额外的参数
39 | //以上三个配置项详情请看小程序文档
40 | }
41 | }),
42 | img2: ImageUploader.mergeData({
43 | imageUploadTitle: '定制标题2'
44 | })
45 | },
46 | onLoad: function(){
47 | new ImageUploader(this, 'img1');//第一个参数必须是 this ，指向 page 实例；第二个参数是组件的 key
48 | new ImageUploader(this, 'img2');
49 | }
50 | });
51 | ```
52 | ## licence
53 | MIT
54 |
--------------------------------------------------------------------------------
/app.js:
--------------------------------------------------------------------------------
1 | App({
2 | onLaunch: function () {
3 |
4 | }
5 | });
6 |
--------------------------------------------------------------------------------
/app.json:
--------------------------------------------------------------------------------
1 | {
2 | "pages": [
3 | "pages/upload_img_demo/index"
4 | ],
5 | "window": {
6 | "backgroundTextStyle": "light",
7 | "navigationBarBackgroundColor": "#fff",
8 | "navigationBarTitleText": "upload_img_demo",
9 | "navigationBarTextStyle": "black",
10 | "enablePullDownRefresh": true
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/app.wxss:
--------------------------------------------------------------------------------
1 | /**app.wxss**/
2 | /* reset */
3 | page {
4 | background-color: #F8F8F8;
5 | height: 100%;
6 | font-size: 32rpx;
7 | line-height: 1.6;
8 | }
9 | checkbox, radio {
10 | margin-right: 10rpx;
11 | }
12 | button{
13 | margin-top: 20rpx;
14 | margin-bottom: 20rpx;
15 | }
16 | form {
17 | width: 100%;
18 | }
19 |
20 | /* lib */
21 | .strong{
22 | font-weight: bold;
23 | }
24 | .tc{
25 | text-align: center;
26 | }
27 |
28 | /* page */
29 | .container {
30 | display: flex;
31 | flex-direction: column;
32 | min-height: 100%;
33 | justify-content: space-between;
34 | font-size: 32rpx;
35 | font-family: -apple-system-font,Helvetica Neue,Helvetica,sans-serif;
36 | }
37 | .page-head {
38 | padding: 60rpx 50rpx 80rpx;
39 | text-align: center;
40 | }
41 | .page-head-title {
42 | display: inline-block;
43 | padding: 0 40rpx 20rpx 40rpx;
44 | font-size: 32rpx;
45 | color: #BEBEBE;
46 | }
47 | .page-head-line{
48 | margin: 0 auto;
49 | width: 150rpx;
50 | height: 2rpx;
51 | background-color: #D8D8D8;
52 | }
53 | .page-head-desc{
54 | padding-top: 20rpx;
55 | color: #9B9B9B;
56 | font-size: 32rpx;
57 | }
58 |
59 | .page-body {
60 | width: 100%;
61 | flex-grow: 1;
62 | overflow-x: hidden;
63 | }
64 | .page-body-wrapper {
65 | display: flex;
66 | flex-direction: column;
67 | align-items: center;
68 | width: 100%;
69 | }
70 | .page-body-wording {
71 | text-align: center;
72 | padding: 200rpx 100rpx;
73 | }
74 | .page-body-info {
75 | display: flex;
76 | flex-direction: column;
77 | align-items: center;
78 | background-color: #fff;
79 | width: 100%;
80 | padding: 50rpx 0 150rpx 0;
81 | }
82 | .page-body-title {
83 | margin-bottom: 100rpx;
84 | font-size: 32rpx;
85 | }
86 | .page-body-text {
87 | font-size: 30rpx;
88 | line-height: 26px;
89 | color: #ccc;
90 | }
91 | .page-body-text-small {
92 | font-size: 24rpx;
93 | color: #000;
94 | margin-bottom: 100rpx;
95 | }
96 |
97 | .page-foot{
98 | margin: 100rpx 0 30rpx 0;
99 | text-align: center;
100 | color: #1aad19;
101 | font-size: 0;
102 | }
103 | .icon-foot{
104 | width: 152rpx;
105 | height: 23rpx;
106 | }
107 |
108 | .page-section{
109 | width: 100%;
110 | margin-bottom: 60rpx;
111 | }
112 | .page-section_center{
113 | display: flex;
114 | flex-direction: column;
115 | align-items: center;
116 | }
117 | .page-section:last-child{
118 | margin-bottom: 0;
119 | }
120 | .page-section-gap{
121 | box-sizing: border-box;
122 | padding: 0 30rpx;
123 | }
124 | .page-section-spacing{
125 | box-sizing: border-box;
126 | padding: 0 80rpx;
127 | }
128 | .page-section-title{
129 | font-size: 28rpx;
130 | color: #999999;
131 | margin-bottom: 10rpx;
132 | padding-left: 30rpx;
133 | padding-right: 30rpx;
134 | }
135 | .page-section-gap .page-section-title{
136 | padding-left: 0;
137 | padding-right: 0;
138 | }
139 |
140 | /* widget */
141 | .btn-area{
142 | margin-top: 60rpx;
143 | box-sizing: border-box;
144 | width: 100%;
145 | padding: 0 30rpx;
146 | }
147 |
148 | .image-plus {
149 | width: 150rpx;
150 | height: 150rpx;
151 | border: 2rpx solid #D9D9D9;
152 | position: relative;
153 | }
154 | .image-plus-nb{
155 | border: 0;
156 | }
157 | .image-plus-text{
158 | color: #888888;
159 | font-size: 28rpx;
160 | }
161 | .image-plus-horizontal {
162 | position: absolute;
163 | top: 50%;
164 | left: 50%;
165 | background-color: #d9d9d9;
166 | width: 4rpx;
167 | height: 80rpx;
168 | transform: translate(-50%, -50%);
169 | }
170 | .image-plus-vertical {
171 | position: absolute;
172 | top: 50%;
173 | left: 50%;
174 | background-color: #d9d9d9;
175 | width: 80rpx;
176 | height: 4rpx;
177 | transform: translate(-50%, -50%);
178 | }
--------------------------------------------------------------------------------
/pages/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yiyizym/wechat_mini_program_upload_img_module/aadf092f07594804150e7a63aaed29ed3904e0e7/pages/.DS_Store
--------------------------------------------------------------------------------
/pages/common/image_uploader/image_uploader.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const Promise = require('../../../utils/bluebird.js');
3 | const wechat = require('../../../utils/wechat.js');
4 | const util = require('../../../utils/util.js');
5 |
6 | const defaultData = {
7 | _chooseImage: 'chooseImage',
8 | _previewImage: 'previewImage',
9 | // 这个方法可以用来设置选择好图片后的回调，但不成熟，先注释掉
10 | // setChooseImageCallback: 'setChooseImageCallback',
11 | imageUploadTitle: '上传图片',
12 | sourceType: ['camera', 'album'],
13 | sizeType: ['compressed'],
14 | maxCount: 1,
15 | uploadedImagesPaths: [],
16 | uploadParams: {
17 | url: '',
18 | name: 'file',
19 | formData: {}
20 | }
21 | };
22 |
23 | class ImageUploader {
24 | // 请确保 key 是唯一的，否则同一个页面内多个实例的数据和方法会互相覆盖
25 | constructor(pageContext, key = ''){
26 | let that = this;
27 | this.key = key;
28 | this.page = pageContext;
29 | this.data = this.page.data[key];
30 |
31 | this.data._chooseImage = this.data._chooseImage + key;
32 | this.data._previewImage = this.data._previewImage + key;
33 | // this.data.setChooseImageCallback = this.data.setChooseImageCallback + key;
34 |
35 | let uploadedImagesPaths = `${key}.uploadedImagesPaths`;
36 | this.page.setData({
37 | [key]: this.data,
38 | [uploadedImagesPaths]: [] // 为了在有默认图片时，点击 previewImage 生效
39 | });
40 |
41 | // 为了在有默认图片时，点击 previewImage 生效
42 | this.page.setData({
43 | [uploadedImagesPaths]: this.data.uploadedImagesPaths
44 | });
45 |
46 |
47 | this.page[this.data._chooseImage] = this.chooseImage.bind(this);
48 | this.page[this.data._previewImage] = this.previewImage.bind(this);
49 | // this.page[this.data.setChooseImageCallback] = this.setChooseImageCallback.bind(this);
50 |
51 | }
52 |
53 | chooseImage() {
54 | let data = this.data;
55 | wechat.chooseImage(data.sourceType, data.sizeType, data.maxCount).then(res => {
56 | this._chooseImageCb(res);
57 | },e => {
58 | console.log(e);
59 | });
60 | }
61 |
62 | previewImage(e) {
63 | let current = e.target.dataset.src;
64 | wx.previewImage({
65 | current: current,
66 | urls: this.data.uploadedImagesPaths
67 | });
68 | }
69 |
70 | // setChooseImageCallback(cb){
71 | // if(typeof cb == 'function'){
72 | // this._chooseImageCb = cb;
73 | // }
74 | // else {
75 | // throw 'setChooseImageCallback receives a "function" as argument';
76 | // }
77 | // }
78 |
79 | _chooseImageCb(res){
80 | let filePath = res.tempFilePaths[0];
81 | this._uploadImage(res).then(res => {
82 | this._addToUploadedPaths(res, filePath);
83 | }, e => {
84 | console.log(e);
85 | });
86 | }
87 |
88 | _uploadImage(res){
89 | let data = this.data;
90 | let filePath = res.tempFilePaths[0];
91 | let uploadParams = data.uploadParams;
92 | let formData = Object.assign({}, uploadParams['formData'], {});
93 |
94 | console.info('为了演示效果，直接 resolve true ，真实使用时，请删除 return Promise.resolve(true);');
95 | return Promise.resolve(true);
96 |
97 | return wechat.uploadFile(uploadParams['url'],filePath,uploadParams['name'], formData);
98 | }
99 |
100 | _addToUploadedPaths(resp, filePath){
101 | if (this._isUploadSuccess(resp)) {
102 | this.data.uploadedImagesPaths.push(filePath);
103 | this.page.setData({
104 | [this.key]: this.data
105 | });
106 | }
107 | else {
108 | console.error(resp);
109 | }
110 | }
111 | _isUploadSuccess(resp){
112 | console.info('为了演示效果，直接 return true ，真实使用时，请写自己的判断逻辑');
113 | return true;
114 | }
115 |
116 | }
117 |
118 | ImageUploader.mergeData = function(data){
119 | return util.mergeDeep({}, defaultData, data);
120 | };
121 |
122 | module.exports = ImageUploader;
123 |
124 |
--------------------------------------------------------------------------------
/pages/common/image_uploader/image_uploader.wxml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | {{imageUploadTitle}}
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
--------------------------------------------------------------------------------
/pages/common/image_uploader/image_uploader.wxss:
--------------------------------------------------------------------------------
1 | @import '../lib/weui.wxss';
--------------------------------------------------------------------------------
/pages/common/lib/weui.wxss:
--------------------------------------------------------------------------------
1 | /*!
2 | * weui.js v1.1.0 (https://github.com/weui/weui-wxss)
3 | * Copyright 2016, wechat ui team
4 | * MIT license
5 | */
6 | page {
7 | line-height: 1.6;
8 | font-family: -apple-system-font, "Helvetica Neue", sans-serif;
9 | }
10 | icon {
11 | vertical-align: middle;
12 | }
13 | .weui-cells {
14 | position: relative;
15 | margin-top: 1.17647059em;
16 | background-color: #FFFFFF;
17 | line-height: 1.41176471;
18 | font-size: 17px;
19 | }
20 | .weui-cells:before {
21 | content: " ";
22 | position: absolute;
23 | left: 0;
24 | top: 0;
25 | right: 0;
26 | height: 1px;
27 | border-top: 1rpx solid #D9D9D9;
28 | color: #D9D9D9;
29 | }
30 | .weui-cells:after {
31 | content: " ";
32 | position: absolute;
33 | left: 0;
34 | bottom: 0;
35 | right: 0;
36 | height: 1px;
37 | border-bottom: 1rpx solid #D9D9D9;
38 | color: #D9D9D9;
39 | }
40 | .weui-cells__title {
41 | margin-top: .77em;
42 | margin-bottom: .3em;
43 | padding-left: 15px;
44 | padding-right: 15px;
45 | color: #999999;
46 | font-size: 14px;
47 | }
48 | .weui-cells_after-title {
49 | margin-top: 0;
50 | }
51 | .weui-cells__tips {
52 | margin-top: .3em;
53 | color: #999999;
54 | padding-left: 15px;
55 | padding-right: 15px;
56 | font-size: 14px;
57 | }
58 | .weui-cell {
59 | padding: 10px 15px;
60 | position: relative;
61 | display: -webkit-box;
62 | display: -webkit-flex;
63 | display: flex;
64 | -webkit-box-align: center;
65 | -webkit-align-items: center;
66 | align-items: center;
67 | }
68 | .weui-cell:before {
69 | content: " ";
70 | position: absolute;
71 | left: 0;
72 | top: 0;
73 | right: 0;
74 | height: 1px;
75 | border-top: 1rpx solid #D9D9D9;
76 | color: #D9D9D9;
77 | left: 15px;
78 | }
79 | .weui-cell:first-child:before {
80 | display: none;
81 | }
82 | .weui-cell_active {
83 | background-color: #ECECEC;
84 | }
85 | .weui-cell_primary {
86 | -webkit-box-align: start;
87 | -webkit-align-items: flex-start;
88 | align-items: flex-start;
89 | }
90 | .weui-cell__bd {
91 | -webkit-box-flex: 1;
92 | -webkit-flex: 1;
93 | flex: 1;
94 | }
95 | .weui-cell__ft {
96 | text-align: right;
97 | color: #999999;
98 | }
99 | .weui-cell_access {
100 | color: inherit;
101 | }
102 | .weui-cell__ft_in-access {
103 | padding-right: 13px;
104 | position: relative;
105 | }
106 | .weui-cell__ft_in-access:after {
107 | content: " ";
108 | display: inline-block;
109 | height: 6px;
110 | width: 6px;
111 | border-width: 2px 2px 0 0;
112 | border-color: #C8C8CD;
113 | border-style: solid;
114 | -webkit-transform: matrix(0.71, 0.71, -0.71, 0.71, 0, 0);
115 | transform: matrix(0.71, 0.71, -0.71, 0.71, 0, 0);
116 | position: relative;
117 | top: -2px;
118 | position: absolute;
119 | top: 50%;
120 | margin-top: -4px;
121 | right: 2px;
122 | }
123 | .weui-cell_link {
124 | color: #586C94;
125 | font-size: 14px;
126 | }
127 | .weui-cell_link:active {
128 | background-color: #ECECEC;
129 | }
130 | .weui-cell_link:first-child:before {
131 | display: block;
132 | }
133 | .weui-icon-radio {
134 | margin-left: 3.2px;
135 | margin-right: 3.2px;
136 | }
137 | .weui-icon-checkbox_circle,
138 | .weui-icon-checkbox_success {
139 | margin-left: 4.6px;
140 | margin-right: 4.6px;
141 | }
142 | .weui-check__label:active {
143 | background-color: #ECECEC;
144 | }
145 | .weui-check {
146 | position: absolute;
147 | left: -9999px;
148 | }
149 | .weui-check__hd_in-checkbox {
150 | padding-right: 0.35em;
151 | }
152 | .weui-cell__ft_in-radio {
153 | padding-left: 0.35em;
154 | }
155 | .weui-cell_input {
156 | padding-top: 0;
157 | padding-bottom: 0;
158 | }
159 | .weui-label {
160 | width: 105px;
161 | word-wrap: break-word;
162 | word-break: break-all;
163 | }
164 | .weui-input {
165 | height: 2.58823529em;
166 | min-height: 2.58823529em;
167 | line-height: 2.58823529em;
168 | }
169 | .weui-toptips {
170 | position: fixed;
171 | -webkit-transform: translateZ(0);
172 | transform: translateZ(0);
173 | top: 0;
174 | left: 0;
175 | right: 0;
176 | padding: 5px;
177 | font-size: 14px;
178 | text-align: center;
179 | color: #FFFFFF;
180 | z-index: 5000;
181 | word-wrap: break-word;
182 | word-break: break-all;
183 | }
184 | .weui-toptips_warn {
185 | background-color: #E64340;
186 | }
187 | .weui-textarea {
188 | display: block;
189 | width: 100%;
190 | }
191 | .weui-textarea-counter {
192 | color: #B2B2B2;
193 | text-align: right;
194 | }
195 | .weui-textarea-counter_warn {
196 | color: #E64340;
197 | }
198 | .weui-cell_warn {
199 | color: #E64340;
200 | }
201 | .weui-form-preview {
202 | position: relative;
203 | background-color: #FFFFFF;
204 | }
205 | .weui-form-preview:before {
206 | content: " ";
207 | position: absolute;
208 | left: 0;
209 | top: 0;
210 | right: 0;
211 | height: 1px;
212 | border-top: 1rpx solid #D9D9D9;
213 | color: #D9D9D9;
214 | }
215 | .weui-form-preview:after {
216 | content: " ";
217 | position: absolute;
218 | left: 0;
219 | bottom: 0;
220 | right: 0;
221 | height: 1px;
222 | border-bottom: 1rpx solid #D9D9D9;
223 | color: #D9D9D9;
224 | }
225 | .weui-form-preview__value {
226 | font-size: 14px;
227 | }
228 | .weui-form-preview__value_in-hd {
229 | font-size: 26px;
230 | }
231 | .weui-form-preview__hd {
232 | position: relative;
233 | padding: 10px 15px;
234 | text-align: right;
235 | line-height: 2.5em;
236 | }
237 | .weui-form-preview__hd:after {
238 | content: " ";
239 | position: absolute;
240 | left: 0;
241 | bottom: 0;
242 | right: 0;
243 | height: 1px;
244 | border-bottom: 1rpx solid #D9D9D9;
245 | color: #D9D9D9;
246 | left: 15px;
247 | }
248 | .weui-form-preview__bd {
249 | padding: 10px 15px;
250 | font-size: .9em;
251 | text-align: right;
252 | color: #999999;
253 | line-height: 2;
254 | }
255 | .weui-form-preview__ft {
256 | position: relative;
257 | line-height: 50px;
258 | display: -webkit-box;
259 | display: -webkit-flex;
260 | display: flex;
261 | }
262 | .weui-form-preview__ft:after {
263 | content: " ";
264 | position: absolute;
265 | left: 0;
266 | top: 0;
267 | right: 0;
268 | height: 1px;
269 | border-top: 1rpx solid #D5D5D6;
270 | color: #D5D5D6;
271 | }
272 | .weui-form-preview__item {
273 | overflow: hidden;
274 | }
275 | .weui-form-preview__label {
276 | float: left;
277 | margin-right: 1em;
278 | min-width: 4em;
279 | color: #999999;
280 | text-align: justify;
281 | text-align-last: justify;
282 | }
283 | .weui-form-preview__value {
284 | display: block;
285 | overflow: hidden;
286 | word-break: normal;
287 | word-wrap: break-word;
288 | }
289 | .weui-form-preview__btn {
290 | position: relative;
291 | display: block;
292 | -webkit-box-flex: 1;
293 | -webkit-flex: 1;
294 | flex: 1;
295 | color: #3CC51F;
296 | text-align: center;
297 | }
298 | .weui-form-preview__btn:after {
299 | content: " ";
300 | position: absolute;
301 | left: 0;
302 | top: 0;
303 | width: 1px;
304 | bottom: 0;
305 | border-left: 1rpx solid #D5D5D6;
306 | color: #D5D5D6;
307 | }
308 | .weui-form-preview__btn:first-child:after {
309 | display: none;
310 | }
311 | .weui-form-preview__btn_active {
312 | background-color: #EEEEEE;
313 | }
314 | .weui-form-preview__btn_default {
315 | color: #999999;
316 | }
317 | .weui-form-preview__btn_primary {
318 | color: #0BB20C;
319 | }
320 | .weui-cell_select {
321 | padding: 0;
322 | }
323 | .weui-select {
324 | position: relative;
325 | padding-left: 15px;
326 | padding-right: 30px;
327 | height: 2.58823529em;
328 | min-height: 2.58823529em;
329 | line-height: 2.58823529em;
330 | border-right: 1rpx solid #D9D9D9;
331 | }
332 | .weui-select:before {
333 | content: " ";
334 | display: inline-block;
335 | height: 6px;
336 | width: 6px;
337 | border-width: 2px 2px 0 0;
338 | border-color: #C8C8CD;
339 | border-style: solid;
340 | -webkit-transform: matrix(0.71, 0.71, -0.71, 0.71, 0, 0);
341 | transform: matrix(0.71, 0.71, -0.71, 0.71, 0, 0);
342 | position: relative;
343 | top: -2px;
344 | position: absolute;
345 | top: 50%;
346 | right: 15px;
347 | margin-top: -4px;
348 | }
349 | .weui-select_in-select-after {
350 | padding-left: 0;
351 | }
352 | .weui-cell__hd_in-select-after,
353 | .weui-cell__bd_in-select-before {
354 | padding-left: 15px;
355 | }
356 | .weui-cell_vcode {
357 | padding-right: 0;
358 | }
359 | .weui-vcode-img {
360 | margin-left: 5px;
361 | height: 2.58823529em;
362 | vertical-align: middle;
363 | }
364 | .weui-vcode-btn {
365 | display: inline-block;
366 | height: 2.58823529em;
367 | margin-left: 5px;
368 | padding: 0 0.6em 0 0.7em;
369 | border-left: 1px solid #E5E5E5;
370 | line-height: 2.58823529em;
371 | vertical-align: middle;
372 | font-size: 17px;
373 | color: #3CC51F;
374 | white-space: nowrap;
375 | }
376 | .weui-vcode-btn:active {
377 | color: #52a341;
378 | }
379 | .weui-cell_switch {
380 | padding-top: 6px;
381 | padding-bottom: 6px;
382 | }
383 | .weui-uploader__hd {
384 | display: -webkit-box;
385 | display: -webkit-flex;
386 | display: flex;
387 | padding-bottom: 10px;
388 | -webkit-box-align: center;
389 | -webkit-align-items: center;
390 | align-items: center;
391 | }
392 | .weui-uploader__title {
393 | -webkit-box-flex: 1;
394 | -webkit-flex: 1;
395 | flex: 1;
396 | }
397 | .weui-uploader__info {
398 | color: #B2B2B2;
399 | }
400 | .weui-uploader__bd {
401 | margin-bottom: -4px;
402 | margin-right: -9px;
403 | overflow: hidden;
404 | }
405 | .weui-uploader__file {
406 | float: left;
407 | margin-right: 9px;
408 | margin-bottom: 9px;
409 | }
410 | .weui-uploader__img {
411 | display: block;
412 | width: 79px;
413 | height: 79px;
414 | }
415 | .weui-uploader__file_status {
416 | position: relative;
417 | }
418 | .weui-uploader__file_status:before {
419 | content: " ";
420 | position: absolute;
421 | top: 0;
422 | right: 0;
423 | bottom: 0;
424 | left: 0;
425 | background-color: rgba(0, 0, 0, 0.5);
426 | }
427 | .weui-uploader__file-content {
428 | position: absolute;
429 | top: 50%;
430 | left: 50%;
431 | -webkit-transform: translate(-50%, -50%);
432 | transform: translate(-50%, -50%);
433 | color: #FFFFFF;
434 | }
435 | .weui-uploader__input-box {
436 | float: left;
437 | position: relative;
438 | margin-right: 9px;
439 | margin-bottom: 9px;
440 | width: 77px;
441 | height: 77px;
442 | border: 1px solid #D9D9D9;
443 | }
444 | .weui-uploader__input-box:before,
445 | .weui-uploader__input-box:after {
446 | content: " ";
447 | position: absolute;
448 | top: 50%;
449 | left: 50%;
450 | -webkit-transform: translate(-50%, -50%);
451 | transform: translate(-50%, -50%);
452 | background-color: #D9D9D9;
453 | }
454 | .weui-uploader__input-box:before {
455 | width: 2px;
456 | height: 39.5px;
457 | }
458 | .weui-uploader__input-box:after {
459 | width: 39.5px;
460 | height: 2px;
461 | }
462 | .weui-uploader__input-box:active {
463 | border-color: #999999;
464 | }
465 | .weui-uploader__input-box:active:before,
466 | .weui-uploader__input-box:active:after {
467 | background-color: #999999;
468 | }
469 | .weui-uploader__input {
470 | position: absolute;
471 | z-index: 1;
472 | top: 0;
473 | left: 0;
474 | width: 100%;
475 | height: 100%;
476 | opacity: 0;
477 | }
478 | .weui-article {
479 | padding: 20px 15px;
480 | font-size: 15px;
481 | }
482 | .weui-article__section {
483 | margin-bottom: 1.5em;
484 | }
485 | .weui-article__h1 {
486 | font-size: 18px;
487 | font-weight: 400;
488 | margin-bottom: .9em;
489 | }
490 | .weui-article__h2 {
491 | font-size: 16px;
492 | font-weight: 400;
493 | margin-bottom: .34em;
494 | }
495 | .weui-article__h3 {
496 | font-weight: 400;
497 | font-size: 15px;
498 | margin-bottom: .34em;
499 | }
500 | .weui-article__p {
501 | margin: 0 0 .8em;
502 | }
503 | .weui-msg {
504 | padding-top: 36px;
505 | text-align: center;
506 | }
507 | .weui-msg__link {
508 | display: inline;
509 | color: #586C94;
510 | }
511 | .weui-msg__icon-area {
512 | margin-bottom: 30px;
513 | }
514 | .weui-msg__text-area {
515 | margin-bottom: 25px;
516 | padding: 0 20px;
517 | }
518 | .weui-msg__title {
519 | margin-bottom: 5px;
520 | font-weight: 400;
521 | font-size: 20px;
522 | }
523 | .weui-msg__desc {
524 | font-size: 14px;
525 | color: #999999;
526 | }
527 | .weui-msg__opr-area {
528 | margin-bottom: 25px;
529 | }
530 | .weui-msg__extra-area {
531 | margin-bottom: 15px;
532 | font-size: 14px;
533 | color: #999999;
534 | }
535 | @media screen and (min-height: 438px) {
536 | .weui-msg__extra-area {
537 | position: fixed;
538 | left: 0;
539 | bottom: 0;
540 | width: 100%;
541 | text-align: center;
542 | }
543 | }
544 | .weui-flex {
545 | display: -webkit-box;
546 | display: -webkit-flex;
547 | display: flex;
548 | }
549 | .weui-flex__item {
550 | -webkit-box-flex: 1;
551 | -webkit-flex: 1;
552 | flex: 1;
553 | }
554 | .weui-btn {
555 | margin-top: 15px;
556 | }
557 | .weui-btn:first-child {
558 | margin-top: 0;
559 | }
560 | .weui-btn-area {
561 | margin: 1.17647059em 15px 0.3em;
562 | }
563 | .weui-agree {
564 | display: block;
565 | padding: .5em 15px;
566 | font-size: 13px;
567 | }
568 | .weui-agree__text {
569 | color: #999999;
570 | }
571 | .weui-agree__link {
572 | display: inline;
573 | color: #586C94;
574 | }
575 | .weui-agree__checkbox {
576 | position: absolute;
577 | left: -9999px;
578 | }
579 | .weui-agree__checkbox-icon {
580 | position: relative;
581 | top: 2px;
582 | display: inline-block;
583 | border: 1px solid #D1D1D1;
584 | background-color: #FFFFFF;
585 | border-radius: 3px;
586 | width: 11px;
587 | height: 11px;
588 | }
589 | .weui-agree__checkbox-icon-check {
590 | position: absolute;
591 | top: 1px;
592 | left: 1px;
593 | }
594 | .weui-footer {
595 | color: #999999;
596 | font-size: 14px;
597 | text-align: center;
598 | }
599 | .weui-footer_fixed-bottom {
600 | position: fixed;
601 | bottom: .52em;
602 | left: 0;
603 | right: 0;
604 | }
605 | .weui-footer__links {
606 | font-size: 0;
607 | }
608 | .weui-footer__link {
609 | display: inline-block;
610 | vertical-align: top;
611 | margin: 0 .62em;
612 | position: relative;
613 | font-size: 14px;
614 | color: #586C94;
615 | }
616 | .weui-footer__link:before {
617 | content: " ";
618 | position: absolute;
619 | left: 0;
620 | top: 0;
621 | width: 1px;
622 | bottom: 0;
623 | border-left: 1rpx solid #C7C7C7;
624 | color: #C7C7C7;
625 | left: -0.65em;
626 | top: .36em;
627 | bottom: .36em;
628 | }
629 | .weui-footer__link:first-child:before {
630 | display: none;
631 | }
632 | .weui-footer__text {
633 | padding: 0 .34em;
634 | font-size: 12px;
635 | }
636 | .weui-grids {
637 | border-top: 1rpx solid #D9D9D9;
638 | border-left: 1rpx solid #D9D9D9;
639 | overflow: hidden;
640 | }
641 | .weui-grid {
642 | position: relative;
643 | float: left;
644 | padding: 20px 10px;
645 | width: 33.33333333%;
646 | box-sizing: border-box;
647 | border-right: 1rpx solid #D9D9D9;
648 | border-bottom: 1rpx solid #D9D9D9;
649 | }
650 | .weui-grid_active {
651 | background-color: #ECECEC;
652 | }
653 | .weui-grid__icon {
654 | display: block;
655 | width: 28px;
656 | height: 28px;
657 | margin: 0 auto;
658 | }
659 | .weui-grid__label {
660 | margin-top: 5px;
661 | display: block;
662 | text-align: center;
663 | color: #000000;
664 | font-size: 14px;
665 | white-space: nowrap;
666 | text-overflow: ellipsis;
667 | overflow: hidden;
668 | }
669 | .weui-loading {
670 | margin: 0 5px;
671 | width: 20px;
672 | height: 20px;
673 | display: inline-block;
674 | vertical-align: middle;
675 | -webkit-animation: weuiLoading 1s steps(12, end) infinite;
676 | animation: weuiLoading 1s steps(12, end) infinite;
677 | background: transparent url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjAiIGhlaWdodD0iMTIwIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0ibm9uZSIgZD0iTTAgMGgxMDB2MTAwSDB6Ii8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjRTlFOUU5IiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDAgLTMwKSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iIzk4OTY5NyIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgzMCAxMDUuOTggNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjOUI5OTlBIiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKDYwIDc1Ljk4IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0EzQTFBMiIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSg5MCA2NSA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNBQkE5QUEiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoMTIwIDU4LjY2IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0IyQjJCMiIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgxNTAgNTQuMDIgNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjQkFCOEI5IiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKDE4MCA1MCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNDMkMwQzEiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTE1MCA0NS45OCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNDQkNCQ0IiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTEyMCA0MS4zNCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNEMkQyRDIiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTkwIDM1IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0RBREFEQSIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgtNjAgMjQuMDIgNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjRTJFMkUyIiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKC0zMCAtNS45OCA2NSkiLz48L3N2Zz4=) no-repeat;
678 | background-size: 100%;
679 | }
680 | @-webkit-keyframes weuiLoading {
681 | 0% {
682 | -webkit-transform: rotate3d(0, 0, 1, 0deg);
683 | transform: rotate3d(0, 0, 1, 0deg);
684 | }
685 | 100% {
686 | -webkit-transform: rotate3d(0, 0, 1, 360deg);
687 | transform: rotate3d(0, 0, 1, 360deg);
688 | }
689 | }
690 | @keyframes weuiLoading {
691 | 0% {
692 | -webkit-transform: rotate3d(0, 0, 1, 0deg);
693 | transform: rotate3d(0, 0, 1, 0deg);
694 | }
695 | 100% {
696 | -webkit-transform: rotate3d(0, 0, 1, 360deg);
697 | transform: rotate3d(0, 0, 1, 360deg);
698 | }
699 | }
700 | .weui-badge {
701 | display: inline-block;
702 | padding: .15em .4em;
703 | min-width: 8px;
704 | border-radius: 18px;
705 | background-color: #F43530;
706 | color: #FFFFFF;
707 | line-height: 1.2;
708 | text-align: center;
709 | font-size: 12px;
710 | vertical-align: middle;
711 | }
712 | .weui-badge_dot {
713 | padding: .4em;
714 | min-width: 0;
715 | }
716 | .weui-loadmore {
717 | width: 65%;
718 | margin: 1.5em auto;
719 | line-height: 1.6em;
720 | font-size: 14px;
721 | text-align: center;
722 | }
723 | .weui-loadmore__tips {
724 | display: inline-block;
725 | vertical-align: middle;
726 | }
727 | .weui-loadmore_line {
728 | border-top: 1px solid #E5E5E5;
729 | margin-top: 2.4em;
730 | }
731 | .weui-loadmore__tips_in-line {
732 | position: relative;
733 | top: -0.9em;
734 | padding: 0 .55em;
735 | background-color: #FFFFFF;
736 | color: #999999;
737 | }
738 | .weui-loadmore__tips_in-dot {
739 | position: relative;
740 | padding: 0 .16em;
741 | width: 4px;
742 | height: 1.6em;
743 | }
744 | .weui-loadmore__tips_in-dot:before {
745 | content: " ";
746 | position: absolute;
747 | top: 50%;
748 | left: 50%;
749 | margin-top: -1px;
750 | margin-left: -2px;
751 | width: 4px;
752 | height: 4px;
753 | border-radius: 50%;
754 | background-color: #E5E5E5;
755 | }
756 | .weui-panel {
757 | background-color: #FFFFFF;
758 | margin-top: 10px;
759 | position: relative;
760 | overflow: hidden;
761 | }
762 | .weui-panel:first-child {
763 | margin-top: 0;
764 | }
765 | .weui-panel:before {
766 | content: " ";
767 | position: absolute;
768 | left: 0;
769 | top: 0;
770 | right: 0;
771 | height: 1px;
772 | border-top: 1rpx solid #E5E5E5;
773 | color: #E5E5E5;
774 | }
775 | .weui-panel:after {
776 | content: " ";
777 | position: absolute;
778 | left: 0;
779 | bottom: 0;
780 | right: 0;
781 | height: 1px;
782 | border-bottom: 1rpx solid #E5E5E5;
783 | color: #E5E5E5;
784 | }
785 | .weui-panel__hd {
786 | padding: 14px 15px 10px;
787 | color: #999999;
788 | font-size: 13px;
789 | position: relative;
790 | }
791 | .weui-panel__hd:after {
792 | content: " ";
793 | position: absolute;
794 | left: 0;
795 | bottom: 0;
796 | right: 0;
797 | height: 1px;
798 | border-bottom: 1rpx solid #E5E5E5;
799 | color: #E5E5E5;
800 | left: 15px;
801 | }
802 | .weui-media-box {
803 | padding: 15px;
804 | position: relative;
805 | }
806 | .weui-media-box:before {
807 | content: " ";
808 | position: absolute;
809 | left: 0;
810 | top: 0;
811 | right: 0;
812 | height: 1px;
813 | border-top: 1rpx solid #E5E5E5;
814 | color: #E5E5E5;
815 | left: 15px;
816 | }
817 | .weui-media-box:first-child:before {
818 | display: none;
819 | }
820 | .weui-media-box__title {
821 | font-weight: 400;
822 | font-size: 17px;
823 | width: auto;
824 | overflow: hidden;
825 | text-overflow: ellipsis;
826 | white-space: nowrap;
827 | word-wrap: normal;
828 | word-wrap: break-word;
829 | word-break: break-all;
830 | }
831 | .weui-media-box__desc {
832 | color: #999999;
833 | font-size: 13px;
834 | line-height: 1.2;
835 | overflow: hidden;
836 | text-overflow: ellipsis;
837 | display: -webkit-box;
838 | -webkit-box-orient: vertical;
839 | -webkit-line-clamp: 2;
840 | }
841 | .weui-media-box__info {
842 | margin-top: 15px;
843 | padding-bottom: 5px;
844 | font-size: 13px;
845 | color: #CECECE;
846 | line-height: 1em;
847 | list-style: none;
848 | overflow: hidden;
849 | }
850 | .weui-media-box__info__meta {
851 | float: left;
852 | padding-right: 1em;
853 | }
854 | .weui-media-box__info__meta_extra {
855 | padding-left: 1em;
856 | border-left: 1px solid #CECECE;
857 | }
858 | .weui-media-box__title_in-text {
859 | margin-bottom: 8px;
860 | }
861 | .weui-media-box_appmsg {
862 | display: -webkit-box;
863 | display: -webkit-flex;
864 | display: flex;
865 | -webkit-box-align: center;
866 | -webkit-align-items: center;
867 | align-items: center;
868 | }
869 | .weui-media-box__thumb {
870 | width: 100%;
871 | height: 100%;
872 | vertical-align: top;
873 | }
874 | .weui-media-box__hd_in-appmsg {
875 | margin-right: .8em;
876 | width: 60px;
877 | height: 60px;
878 | line-height: 60px;
879 | text-align: center;
880 | }
881 | .weui-media-box__bd_in-appmsg {
882 | -webkit-box-flex: 1;
883 | -webkit-flex: 1;
884 | flex: 1;
885 | min-width: 0;
886 | }
887 | .weui-media-box_small-appmsg {
888 | padding: 0;
889 | }
890 | .weui-cells_in-small-appmsg {
891 | margin-top: 0;
892 | }
893 | .weui-cells_in-small-appmsg:before {
894 | display: none;
895 | }
896 | .weui-progress {
897 | display: -webkit-box;
898 | display: -webkit-flex;
899 | display: flex;
900 | -webkit-box-align: center;
901 | -webkit-align-items: center;
902 | align-items: center;
903 | }
904 | .weui-progress__bar {
905 | -webkit-box-flex: 1;
906 | -webkit-flex: 1;
907 | flex: 1;
908 | }
909 | .weui-progress__opr {
910 | margin-left: 15px;
911 | font-size: 0;
912 | }
913 | .weui-navbar {
914 | display: -webkit-box;
915 | display: -webkit-flex;
916 | display: flex;
917 | position: absolute;
918 | z-index: 500;
919 | top: 0;
920 | width: 100%;
921 | border-bottom: 1rpx solid #CCCCCC;
922 | }
923 | .weui-navbar__item {
924 | position: relative;
925 | display: block;
926 | -webkit-box-flex: 1;
927 | -webkit-flex: 1;
928 | flex: 1;
929 | padding: 13px 0;
930 | text-align: center;
931 | font-size: 0;
932 | }
933 | .weui-navbar__item.weui-bar__item_on {
934 | color: #1AAD19;
935 | }
936 | .weui-navbar__slider {
937 | position: absolute;
938 | content: " ";
939 | left: 0;
940 | bottom: 0;
941 | width: 6em;
942 | height: 3px;
943 | background-color: #1AAD19;
944 | -webkit-transition: -webkit-transform .3s;
945 | transition: -webkit-transform .3s;
946 | transition: transform .3s;
947 | transition: transform .3s, -webkit-transform .3s;
948 | }
949 | .weui-navbar__title {
950 | display: inline-block;
951 | font-size: 15px;
952 | max-width: 8em;
953 | width: auto;
954 | overflow: hidden;
955 | text-overflow: ellipsis;
956 | white-space: nowrap;
957 | word-wrap: normal;
958 | }
959 | .weui-tab {
960 | position: relative;
961 | height: 100%;
962 | }
963 | .weui-tab__panel {
964 | box-sizing: border-box;
965 | height: 100%;
966 | padding-top: 50px;
967 | overflow: auto;
968 | -webkit-overflow-scrolling: touch;
969 | }
970 | .weui-search-bar {
971 | position: relative;
972 | padding: 8px 10px;
973 | display: -webkit-box;
974 | display: -webkit-flex;
975 | display: flex;
976 | box-sizing: border-box;
977 | background-color: #EFEFF4;
978 | border-top: 1rpx solid #D7D6DC;
979 | border-bottom: 1rpx solid #D7D6DC;
980 | }
981 | .weui-icon-search {
982 | margin-right: 8px;
983 | font-size: inherit;
984 | }
985 | .weui-icon-search_in-box {
986 | position: absolute;
987 | left: 10px;
988 | top: 7px;
989 | }
990 | .weui-search-bar__text {
991 | display: inline-block;
992 | font-size: 14px;
993 | vertical-align: middle;
994 | }
995 | .weui-search-bar__form {
996 | position: relative;
997 | -webkit-box-flex: 1;
998 | -webkit-flex: auto;
999 | flex: auto;
1000 | border-radius: 5px;
1001 | background: #FFFFFF;
1002 | border: 1rpx solid #E6E6EA;
1003 | }
1004 | .weui-search-bar__box {
1005 | position: relative;
1006 | padding-left: 30px;
1007 | padding-right: 30px;
1008 | width: 100%;
1009 | box-sizing: border-box;
1010 | z-index: 1;
1011 | }
1012 | .weui-search-bar__input {
1013 | height: 28px;
1014 | line-height: 28px;
1015 | font-size: 14px;
1016 | }
1017 | .weui-icon-clear {
1018 | position: absolute;
1019 | top: 0;
1020 | right: 0;
1021 | padding: 7px 8px;
1022 | font-size: 0;
1023 | }
1024 | .weui-search-bar__label {
1025 | position: absolute;
1026 | top: 0;
1027 | right: 0;
1028 | bottom: 0;
1029 | left: 0;
1030 | z-index: 2;
1031 | border-radius: 3px;
1032 | text-align: center;
1033 | color: #9B9B9B;
1034 | background: #FFFFFF;
1035 | line-height: 28px;
1036 | }
1037 | .weui-search-bar__cancel-btn {
1038 | margin-left: 10px;
1039 | line-height: 28px;
1040 | color: #09BB07;
1041 | white-space: nowrap;
1042 | }
1043 |
--------------------------------------------------------------------------------
/pages/upload_img_demo/index.js:
--------------------------------------------------------------------------------
1 | //index.js
2 | //获取应用实例
3 |
4 | const ImageUploader = require('../common/image_uploader/image_uploader.js');
5 | Page({
6 | data: {
7 | img1: ImageUploader.mergeData({
8 | imageUploadTitle: '定制标题1',
9 |
10 | sourceType: ['camera', 'album'], //上传图片的来源，相机/相册
11 | sizeType: ['compressed'],//上传前是否压缩，默认压缩
12 | maxCount: 1,//一次选择图片的数量
13 | //以上三个配置项详情请看小程序文档
14 |
15 | uploadedImagesPaths: [],//保存已上传的图片路径，也可以设置初始时就显示的图片
16 | uploadParams: {
17 | url: '',//后台接收上传图片的路径
18 | name: 'file',//后台依靠这个字段拿到文件对象
19 | formData: {}//这个字段可以设置传到后台的额外的参数
20 | //以上三个配置项详情请看小程序文档
21 | }
22 | }),
23 | img2: ImageUploader.mergeData({
24 | imageUploadTitle: '定制标题2'
25 | })
26 | },
27 | onLoad: function(){
28 | new ImageUploader(this, 'img1');
29 | new ImageUploader(this, 'img2');
30 | }
31 | });
32 |
--------------------------------------------------------------------------------
/pages/upload_img_demo/index.json:
--------------------------------------------------------------------------------
1 | {}
--------------------------------------------------------------------------------
/pages/upload_img_demo/index.wxml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/pages/upload_img_demo/index.wxss:
--------------------------------------------------------------------------------
1 | /**index.wxss**/
2 | @import '../common/image_uploader/image_uploader.wxss';
--------------------------------------------------------------------------------
/utils/bluebird.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
4 |
5 | /* @preserve
6 | * The MIT License (MIT)
7 | *
8 | * Copyright (c) 2013-2015 Petka Antonov
9 | *
10 | * Permission is hereby granted, free of charge, to any person obtaining a copy
11 | * of this software and associated documentation files (the "Software"), to deal
12 | * in the Software without restriction, including without limitation the rights
13 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 | * copies of the Software, and to permit persons to whom the Software is
15 | * furnished to do so, subject to the following conditions:
16 | *
17 | * The above copyright notice and this permission notice shall be included in
18 | * all copies or substantial portions of the Software.
19 | *
20 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 | * THE SOFTWARE.
27 | *
28 | */
29 | /**
30 | * bluebird build version 3.4.6
31 | * Features enabled: core
32 | * Features disabled: race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
33 | */
34 | !function (e) {
35 | if ("object" == (typeof exports === "undefined" ? "undefined" : _typeof(exports)) && "undefined" != typeof module) module.exports = e();else if ("function" == typeof define && define.amd) define([], e);else {
36 | var f;"undefined" != typeof window ? f = window : "undefined" != typeof global ? f = global : "undefined" != typeof self && (f = self), f.Promise = e();
37 | }
38 | }(function () {
39 | var define, module, exports;return function e(t, n, r) {
40 | function s(o, u) {
41 | if (!n[o]) {
42 | if (!t[o]) {
43 | var a = typeof _dereq_ == "function" && _dereq_;if (!u && a) return a(o, !0);if (i) return i(o, !0);var f = new Error("Cannot find module '" + o + "'");throw f.code = "MODULE_NOT_FOUND", f;
44 | }var l = n[o] = { exports: {} };t[o][0].call(l.exports, function (e) {
45 | var n = t[o][1][e];return s(n ? n : e);
46 | }, l, l.exports, e, t, n, r);
47 | }return n[o].exports;
48 | }var i = typeof _dereq_ == "function" && _dereq_;for (var o = 0; o < r.length; o++) {
49 | s(r[o]);
50 | }return s;
51 | }({ 1: [function (_dereq_, module, exports) {
52 | "use strict";
53 |
54 | var firstLineError;
55 | try {
56 | throw new Error();
57 | } catch (e) {
58 | firstLineError = e;
59 | }
60 | var schedule = _dereq_("./schedule");
61 | var Queue = _dereq_("./queue");
62 | var util = _dereq_("./util");
63 |
64 | function Async() {
65 | this._customScheduler = false;
66 | this._isTickUsed = false;
67 | this._lateQueue = new Queue(16);
68 | this._normalQueue = new Queue(16);
69 | this._haveDrainedQueues = false;
70 | this._trampolineEnabled = true;
71 | var self = this;
72 | this.drainQueues = function () {
73 | self._drainQueues();
74 | };
75 | this._schedule = schedule;
76 | }
77 |
78 | Async.prototype.setScheduler = function (fn) {
79 | var prev = this._schedule;
80 | this._schedule = fn;
81 | this._customScheduler = true;
82 | return prev;
83 | };
84 |
85 | Async.prototype.hasCustomScheduler = function () {
86 | return this._customScheduler;
87 | };
88 |
89 | Async.prototype.enableTrampoline = function () {
90 | this._trampolineEnabled = true;
91 | };
92 |
93 | Async.prototype.disableTrampolineIfNecessary = function () {
94 | if (util.hasDevTools) {
95 | this._trampolineEnabled = false;
96 | }
97 | };
98 |
99 | Async.prototype.haveItemsQueued = function () {
100 | return this._isTickUsed || this._haveDrainedQueues;
101 | };
102 |
103 | Async.prototype.fatalError = function (e, isNode) {
104 | if (isNode) {
105 | process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) + "\n");
106 | process.exit(2);
107 | } else {
108 | this.throwLater(e);
109 | }
110 | };
111 |
112 | Async.prototype.throwLater = function (fn, arg) {
113 | if (arguments.length === 1) {
114 | arg = fn;
115 | fn = function fn() {
116 | throw arg;
117 | };
118 | }
119 | if (typeof setTimeout !== "undefined") {
120 | setTimeout(function () {
121 | fn(arg);
122 | }, 0);
123 | } else try {
124 | this._schedule(function () {
125 | fn(arg);
126 | });
127 | } catch (e) {
128 | throw new Error("No async scheduler available\n\n See http://goo.gl/MqrFmX\n");
129 | }
130 | };
131 |
132 | function AsyncInvokeLater(fn, receiver, arg) {
133 | this._lateQueue.push(fn, receiver, arg);
134 | this._queueTick();
135 | }
136 |
137 | function AsyncInvoke(fn, receiver, arg) {
138 | this._normalQueue.push(fn, receiver, arg);
139 | this._queueTick();
140 | }
141 |
142 | function AsyncSettlePromises(promise) {
143 | this._normalQueue._pushOne(promise);
144 | this._queueTick();
145 | }
146 |
147 | if (!util.hasDevTools) {
148 | Async.prototype.invokeLater = AsyncInvokeLater;
149 | Async.prototype.invoke = AsyncInvoke;
150 | Async.prototype.settlePromises = AsyncSettlePromises;
151 | } else {
152 | Async.prototype.invokeLater = function (fn, receiver, arg) {
153 | if (this._trampolineEnabled) {
154 | AsyncInvokeLater.call(this, fn, receiver, arg);
155 | } else {
156 | this._schedule(function () {
157 | setTimeout(function () {
158 | fn.call(receiver, arg);
159 | }, 100);
160 | });
161 | }
162 | };
163 |
164 | Async.prototype.invoke = function (fn, receiver, arg) {
165 | if (this._trampolineEnabled) {
166 | AsyncInvoke.call(this, fn, receiver, arg);
167 | } else {
168 | this._schedule(function () {
169 | fn.call(receiver, arg);
170 | });
171 | }
172 | };
173 |
174 | Async.prototype.settlePromises = function (promise) {
175 | if (this._trampolineEnabled) {
176 | AsyncSettlePromises.call(this, promise);
177 | } else {
178 | this._schedule(function () {
179 | promise._settlePromises();
180 | });
181 | }
182 | };
183 | }
184 |
185 | Async.prototype.invokeFirst = function (fn, receiver, arg) {
186 | this._normalQueue.unshift(fn, receiver, arg);
187 | this._queueTick();
188 | };
189 |
190 | Async.prototype._drainQueue = function (queue) {
191 | while (queue.length() > 0) {
192 | var fn = queue.shift();
193 | if (typeof fn !== "function") {
194 | fn._settlePromises();
195 | continue;
196 | }
197 | var receiver = queue.shift();
198 | var arg = queue.shift();
199 | fn.call(receiver, arg);
200 | }
201 | };
202 |
203 | Async.prototype._drainQueues = function () {
204 | this._drainQueue(this._normalQueue);
205 | this._reset();
206 | this._haveDrainedQueues = true;
207 | this._drainQueue(this._lateQueue);
208 | };
209 |
210 | Async.prototype._queueTick = function () {
211 | if (!this._isTickUsed) {
212 | this._isTickUsed = true;
213 | this._schedule(this.drainQueues);
214 | }
215 | };
216 |
217 | Async.prototype._reset = function () {
218 | this._isTickUsed = false;
219 | };
220 |
221 | module.exports = Async;
222 | module.exports.firstLineError = firstLineError;
223 | }, { "./queue": 17, "./schedule": 18, "./util": 21 }], 2: [function (_dereq_, module, exports) {
224 | "use strict";
225 |
226 | module.exports = function (Promise, INTERNAL, tryConvertToPromise, debug) {
227 | var calledBind = false;
228 | var rejectThis = function rejectThis(_, e) {
229 | this._reject(e);
230 | };
231 |
232 | var targetRejected = function targetRejected(e, context) {
233 | context.promiseRejectionQueued = true;
234 | context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
235 | };
236 |
237 | var bindingResolved = function bindingResolved(thisArg, context) {
238 | if ((this._bitField & 50397184) === 0) {
239 | this._resolveCallback(context.target);
240 | }
241 | };
242 |
243 | var bindingRejected = function bindingRejected(e, context) {
244 | if (!context.promiseRejectionQueued) this._reject(e);
245 | };
246 |
247 | Promise.prototype.bind = function (thisArg) {
248 | if (!calledBind) {
249 | calledBind = true;
250 | Promise.prototype._propagateFrom = debug.propagateFromFunction();
251 | Promise.prototype._boundValue = debug.boundValueFunction();
252 | }
253 | var maybePromise = tryConvertToPromise(thisArg);
254 | var ret = new Promise(INTERNAL);
255 | ret._propagateFrom(this, 1);
256 | var target = this._target();
257 | ret._setBoundTo(maybePromise);
258 | if (maybePromise instanceof Promise) {
259 | var context = {
260 | promiseRejectionQueued: false,
261 | promise: ret,
262 | target: target,
263 | bindingPromise: maybePromise
264 | };
265 | target._then(INTERNAL, targetRejected, undefined, ret, context);
266 | maybePromise._then(bindingResolved, bindingRejected, undefined, ret, context);
267 | ret._setOnCancel(maybePromise);
268 | } else {
269 | ret._resolveCallback(target);
270 | }
271 | return ret;
272 | };
273 |
274 | Promise.prototype._setBoundTo = function (obj) {
275 | if (obj !== undefined) {
276 | this._bitField = this._bitField | 2097152;
277 | this._boundTo = obj;
278 | } else {
279 | this._bitField = this._bitField & ~2097152;
280 | }
281 | };
282 |
283 | Promise.prototype._isBound = function () {
284 | return (this._bitField & 2097152) === 2097152;
285 | };
286 |
287 | Promise.bind = function (thisArg, value) {
288 | return Promise.resolve(value).bind(thisArg);
289 | };
290 | };
291 | }, {}], 3: [function (_dereq_, module, exports) {
292 | "use strict";
293 |
294 | var old;
295 | if (typeof Promise !== "undefined") old = Promise;
296 | function noConflict() {
297 | try {
298 | if (Promise === bluebird) Promise = old;
299 | } catch (e) {}
300 | return bluebird;
301 | }
302 | var bluebird = _dereq_("./promise")();
303 | bluebird.noConflict = noConflict;
304 | module.exports = bluebird;
305 | }, { "./promise": 15 }], 4: [function (_dereq_, module, exports) {
306 | "use strict";
307 |
308 | module.exports = function (Promise, PromiseArray, apiRejection, debug) {
309 | var util = _dereq_("./util");
310 | var tryCatch = util.tryCatch;
311 | var errorObj = util.errorObj;
312 | var async = Promise._async;
313 |
314 | Promise.prototype["break"] = Promise.prototype.cancel = function () {
315 | if (!debug.cancellation()) return this._warn("cancellation is disabled");
316 |
317 | var promise = this;
318 | var child = promise;
319 | while (promise._isCancellable()) {
320 | if (!promise._cancelBy(child)) {
321 | if (child._isFollowing()) {
322 | child._followee().cancel();
323 | } else {
324 | child._cancelBranched();
325 | }
326 | break;
327 | }
328 |
329 | var parent = promise._cancellationParent;
330 | if (parent == null || !parent._isCancellable()) {
331 | if (promise._isFollowing()) {
332 | promise._followee().cancel();
333 | } else {
334 | promise._cancelBranched();
335 | }
336 | break;
337 | } else {
338 | if (promise._isFollowing()) promise._followee().cancel();
339 | promise._setWillBeCancelled();
340 | child = promise;
341 | promise = parent;
342 | }
343 | }
344 | };
345 |
346 | Promise.prototype._branchHasCancelled = function () {
347 | this._branchesRemainingToCancel--;
348 | };
349 |
350 | Promise.prototype._enoughBranchesHaveCancelled = function () {
351 | return this._branchesRemainingToCancel === undefined || this._branchesRemainingToCancel <= 0;
352 | };
353 |
354 | Promise.prototype._cancelBy = function (canceller) {
355 | if (canceller === this) {
356 | this._branchesRemainingToCancel = 0;
357 | this._invokeOnCancel();
358 | return true;
359 | } else {
360 | this._branchHasCancelled();
361 | if (this._enoughBranchesHaveCancelled()) {
362 | this._invokeOnCancel();
363 | return true;
364 | }
365 | }
366 | return false;
367 | };
368 |
369 | Promise.prototype._cancelBranched = function () {
370 | if (this._enoughBranchesHaveCancelled()) {
371 | this._cancel();
372 | }
373 | };
374 |
375 | Promise.prototype._cancel = function () {
376 | if (!this._isCancellable()) return;
377 | this._setCancelled();
378 | async.invoke(this._cancelPromises, this, undefined);
379 | };
380 |
381 | Promise.prototype._cancelPromises = function () {
382 | if (this._length() > 0) this._settlePromises();
383 | };
384 |
385 | Promise.prototype._unsetOnCancel = function () {
386 | this._onCancelField = undefined;
387 | };
388 |
389 | Promise.prototype._isCancellable = function () {
390 | return this.isPending() && !this._isCancelled();
391 | };
392 |
393 | Promise.prototype.isCancellable = function () {
394 | return this.isPending() && !this.isCancelled();
395 | };
396 |
397 | Promise.prototype._doInvokeOnCancel = function (onCancelCallback, internalOnly) {
398 | if (util.isArray(onCancelCallback)) {
399 | for (var i = 0; i < onCancelCallback.length; ++i) {
400 | this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
401 | }
402 | } else if (onCancelCallback !== undefined) {
403 | if (typeof onCancelCallback === "function") {
404 | if (!internalOnly) {
405 | var e = tryCatch(onCancelCallback).call(this._boundValue());
406 | if (e === errorObj) {
407 | this._attachExtraTrace(e.e);
408 | async.throwLater(e.e);
409 | }
410 | }
411 | } else {
412 | onCancelCallback._resultCancelled(this);
413 | }
414 | }
415 | };
416 |
417 | Promise.prototype._invokeOnCancel = function () {
418 | var onCancelCallback = this._onCancel();
419 | this._unsetOnCancel();
420 | async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
421 | };
422 |
423 | Promise.prototype._invokeInternalOnCancel = function () {
424 | if (this._isCancellable()) {
425 | this._doInvokeOnCancel(this._onCancel(), true);
426 | this._unsetOnCancel();
427 | }
428 | };
429 |
430 | Promise.prototype._resultCancelled = function () {
431 | this.cancel();
432 | };
433 | };
434 | }, { "./util": 21 }], 5: [function (_dereq_, module, exports) {
435 | "use strict";
436 |
437 | module.exports = function (NEXT_FILTER) {
438 | var util = _dereq_("./util");
439 | var getKeys = _dereq_("./es5").keys;
440 | var tryCatch = util.tryCatch;
441 | var errorObj = util.errorObj;
442 |
443 | function catchFilter(instances, cb, promise) {
444 | return function (e) {
445 | var boundTo = promise._boundValue();
446 | predicateLoop: for (var i = 0; i < instances.length; ++i) {
447 | var item = instances[i];
448 |
449 | if (item === Error || item != null && item.prototype instanceof Error) {
450 | if (e instanceof item) {
451 | return tryCatch(cb).call(boundTo, e);
452 | }
453 | } else if (typeof item === "function") {
454 | var matchesPredicate = tryCatch(item).call(boundTo, e);
455 | if (matchesPredicate === errorObj) {
456 | return matchesPredicate;
457 | } else if (matchesPredicate) {
458 | return tryCatch(cb).call(boundTo, e);
459 | }
460 | } else if (util.isObject(e)) {
461 | var keys = getKeys(item);
462 | for (var j = 0; j < keys.length; ++j) {
463 | var key = keys[j];
464 | if (item[key] != e[key]) {
465 | continue predicateLoop;
466 | }
467 | }
468 | return tryCatch(cb).call(boundTo, e);
469 | }
470 | }
471 | return NEXT_FILTER;
472 | };
473 | }
474 |
475 | return catchFilter;
476 | };
477 | }, { "./es5": 10, "./util": 21 }], 6: [function (_dereq_, module, exports) {
478 | "use strict";
479 |
480 | module.exports = function (Promise) {
481 | var longStackTraces = false;
482 | var contextStack = [];
483 |
484 | Promise.prototype._promiseCreated = function () {};
485 | Promise.prototype._pushContext = function () {};
486 | Promise.prototype._popContext = function () {
487 | return null;
488 | };
489 | Promise._peekContext = Promise.prototype._peekContext = function () {};
490 |
491 | function Context() {
492 | this._trace = new Context.CapturedTrace(peekContext());
493 | }
494 | Context.prototype._pushContext = function () {
495 | if (this._trace !== undefined) {
496 | this._trace._promiseCreated = null;
497 | contextStack.push(this._trace);
498 | }
499 | };
500 |
501 | Context.prototype._popContext = function () {
502 | if (this._trace !== undefined) {
503 | var trace = contextStack.pop();
504 | var ret = trace._promiseCreated;
505 | trace._promiseCreated = null;
506 | return ret;
507 | }
508 | return null;
509 | };
510 |
511 | function createContext() {
512 | if (longStackTraces) return new Context();
513 | }
514 |
515 | function peekContext() {
516 | var lastIndex = contextStack.length - 1;
517 | if (lastIndex >= 0) {
518 | return contextStack[lastIndex];
519 | }
520 | return undefined;
521 | }
522 | Context.CapturedTrace = null;
523 | Context.create = createContext;
524 | Context.deactivateLongStackTraces = function () {};
525 | Context.activateLongStackTraces = function () {
526 | var Promise_pushContext = Promise.prototype._pushContext;
527 | var Promise_popContext = Promise.prototype._popContext;
528 | var Promise_PeekContext = Promise._peekContext;
529 | var Promise_peekContext = Promise.prototype._peekContext;
530 | var Promise_promiseCreated = Promise.prototype._promiseCreated;
531 | Context.deactivateLongStackTraces = function () {
532 | Promise.prototype._pushContext = Promise_pushContext;
533 | Promise.prototype._popContext = Promise_popContext;
534 | Promise._peekContext = Promise_PeekContext;
535 | Promise.prototype._peekContext = Promise_peekContext;
536 | Promise.prototype._promiseCreated = Promise_promiseCreated;
537 | longStackTraces = false;
538 | };
539 | longStackTraces = true;
540 | Promise.prototype._pushContext = Context.prototype._pushContext;
541 | Promise.prototype._popContext = Context.prototype._popContext;
542 | Promise._peekContext = Promise.prototype._peekContext = peekContext;
543 | Promise.prototype._promiseCreated = function () {
544 | var ctx = this._peekContext();
545 | if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
546 | };
547 | };
548 | return Context;
549 | };
550 | }, {}], 7: [function (_dereq_, module, exports) {
551 | "use strict";
552 |
553 | module.exports = function (Promise, Context) {
554 | var getDomain = Promise._getDomain;
555 | var async = Promise._async;
556 | var Warning = _dereq_("./errors").Warning;
557 | var util = _dereq_("./util");
558 | var canAttachTrace = util.canAttachTrace;
559 | var unhandledRejectionHandled;
560 | var possiblyUnhandledRejection;
561 | var bluebirdFramePattern = /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
562 | var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/;
563 | var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/;
564 | var stackFramePattern = null;
565 | var formatStack = null;
566 | var indentStackFrames = false;
567 | var printWarning;
568 | var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 && (true || util.env("BLUEBIRD_DEBUG") || util.env("NODE_ENV") === "development"));
569 |
570 | var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 && (debugging || util.env("BLUEBIRD_WARNINGS")));
571 |
572 | var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 && (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
573 |
574 | var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 && (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
575 |
576 | Promise.prototype.suppressUnhandledRejections = function () {
577 | var target = this._target();
578 | target._bitField = target._bitField & ~1048576 | 524288;
579 | };
580 |
581 | Promise.prototype._ensurePossibleRejectionHandled = function () {
582 | if ((this._bitField & 524288) !== 0) return;
583 | this._setRejectionIsUnhandled();
584 | async.invokeLater(this._notifyUnhandledRejection, this, undefined);
585 | };
586 |
587 | Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
588 | fireRejectionEvent("rejectionHandled", unhandledRejectionHandled, undefined, this);
589 | };
590 |
591 | Promise.prototype._setReturnedNonUndefined = function () {
592 | this._bitField = this._bitField | 268435456;
593 | };
594 |
595 | Promise.prototype._returnedNonUndefined = function () {
596 | return (this._bitField & 268435456) !== 0;
597 | };
598 |
599 | Promise.prototype._notifyUnhandledRejection = function () {
600 | if (this._isRejectionUnhandled()) {
601 | var reason = this._settledValue();
602 | this._setUnhandledRejectionIsNotified();
603 | fireRejectionEvent("unhandledRejection", possiblyUnhandledRejection, reason, this);
604 | }
605 | };
606 |
607 | Promise.prototype._setUnhandledRejectionIsNotified = function () {
608 | this._bitField = this._bitField | 262144;
609 | };
610 |
611 | Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
612 | this._bitField = this._bitField & ~262144;
613 | };
614 |
615 | Promise.prototype._isUnhandledRejectionNotified = function () {
616 | return (this._bitField & 262144) > 0;
617 | };
618 |
619 | Promise.prototype._setRejectionIsUnhandled = function () {
620 | this._bitField = this._bitField | 1048576;
621 | };
622 |
623 | Promise.prototype._unsetRejectionIsUnhandled = function () {
624 | this._bitField = this._bitField & ~1048576;
625 | if (this._isUnhandledRejectionNotified()) {
626 | this._unsetUnhandledRejectionIsNotified();
627 | this._notifyUnhandledRejectionIsHandled();
628 | }
629 | };
630 |
631 | Promise.prototype._isRejectionUnhandled = function () {
632 | return (this._bitField & 1048576) > 0;
633 | };
634 |
635 | Promise.prototype._warn = function (message, shouldUseOwnTrace, promise) {
636 | return warn(message, shouldUseOwnTrace, promise || this);
637 | };
638 |
639 | Promise.onPossiblyUnhandledRejection = function (fn) {
640 | var domain = getDomain();
641 | possiblyUnhandledRejection = typeof fn === "function" ? domain === null ? fn : util.domainBind(domain, fn) : undefined;
642 | };
643 |
644 | Promise.onUnhandledRejectionHandled = function (fn) {
645 | var domain = getDomain();
646 | unhandledRejectionHandled = typeof fn === "function" ? domain === null ? fn : util.domainBind(domain, fn) : undefined;
647 | };
648 |
649 | var disableLongStackTraces = function disableLongStackTraces() {};
650 | Promise.longStackTraces = function () {
651 | if (async.haveItemsQueued() && !config.longStackTraces) {
652 | throw new Error("cannot enable long stack traces after promises have been created\n\n See http://goo.gl/MqrFmX\n");
653 | }
654 | if (!config.longStackTraces && longStackTracesIsSupported()) {
655 | var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
656 | var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
657 | config.longStackTraces = true;
658 | disableLongStackTraces = function disableLongStackTraces() {
659 | if (async.haveItemsQueued() && !config.longStackTraces) {
660 | throw new Error("cannot enable long stack traces after promises have been created\n\n See http://goo.gl/MqrFmX\n");
661 | }
662 | Promise.prototype._captureStackTrace = Promise_captureStackTrace;
663 | Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
664 | Context.deactivateLongStackTraces();
665 | async.enableTrampoline();
666 | config.longStackTraces = false;
667 | };
668 | Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
669 | Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
670 | Context.activateLongStackTraces();
671 | async.disableTrampolineIfNecessary();
672 | }
673 | };
674 |
675 | Promise.hasLongStackTraces = function () {
676 | return config.longStackTraces && longStackTracesIsSupported();
677 | };
678 |
679 | var fireDomEvent = function () {
680 | try {
681 | if (typeof CustomEvent === "function") {
682 | var event = new CustomEvent("CustomEvent");
683 | util.global.dispatchEvent(event);
684 | return function (name, event) {
685 | var domEvent = new CustomEvent(name.toLowerCase(), {
686 | detail: event,
687 | cancelable: true
688 | });
689 | return !util.global.dispatchEvent(domEvent);
690 | };
691 | } else if (typeof Event === "function") {
692 | var event = new Event("CustomEvent");
693 | util.global.dispatchEvent(event);
694 | return function (name, event) {
695 | var domEvent = new Event(name.toLowerCase(), {
696 | cancelable: true
697 | });
698 | domEvent.detail = event;
699 | return !util.global.dispatchEvent(domEvent);
700 | };
701 | } else {
702 | var event = document.createEvent("CustomEvent");
703 | event.initCustomEvent("testingtheevent", false, true, {});
704 | util.global.dispatchEvent(event);
705 | return function (name, event) {
706 | var domEvent = document.createEvent("CustomEvent");
707 | domEvent.initCustomEvent(name.toLowerCase(), false, true, event);
708 | return !util.global.dispatchEvent(domEvent);
709 | };
710 | }
711 | } catch (e) {}
712 | return function () {
713 | return false;
714 | };
715 | }();
716 |
717 | var fireGlobalEvent = function () {
718 | if (util.isNode) {
719 | return function () {
720 | return process.emit.apply(process, arguments);
721 | };
722 | } else {
723 | if (!util.global) {
724 | return function () {
725 | return false;
726 | };
727 | }
728 | return function (name) {
729 | var methodName = "on" + name.toLowerCase();
730 | var method = util.global[methodName];
731 | if (!method) return false;
732 | method.apply(util.global, [].slice.call(arguments, 1));
733 | return true;
734 | };
735 | }
736 | }();
737 |
738 | function generatePromiseLifecycleEventObject(name, promise) {
739 | return { promise: promise };
740 | }
741 |
742 | var eventToObjectGenerator = {
743 | promiseCreated: generatePromiseLifecycleEventObject,
744 | promiseFulfilled: generatePromiseLifecycleEventObject,
745 | promiseRejected: generatePromiseLifecycleEventObject,
746 | promiseResolved: generatePromiseLifecycleEventObject,
747 | promiseCancelled: generatePromiseLifecycleEventObject,
748 | promiseChained: function promiseChained(name, promise, child) {
749 | return { promise: promise, child: child };
750 | },
751 | warning: function warning(name, _warning) {
752 | return { warning: _warning };
753 | },
754 | unhandledRejection: function unhandledRejection(name, reason, promise) {
755 | return { reason: reason, promise: promise };
756 | },
757 | rejectionHandled: generatePromiseLifecycleEventObject
758 | };
759 |
760 | var activeFireEvent = function activeFireEvent(name) {
761 | var globalEventFired = false;
762 | try {
763 | globalEventFired = fireGlobalEvent.apply(null, arguments);
764 | } catch (e) {
765 | async.throwLater(e);
766 | globalEventFired = true;
767 | }
768 |
769 | var domEventFired = false;
770 | try {
771 | domEventFired = fireDomEvent(name, eventToObjectGenerator[name].apply(null, arguments));
772 | } catch (e) {
773 | async.throwLater(e);
774 | domEventFired = true;
775 | }
776 |
777 | return domEventFired || globalEventFired;
778 | };
779 |
780 | Promise.config = function (opts) {
781 | opts = Object(opts);
782 | if ("longStackTraces" in opts) {
783 | if (opts.longStackTraces) {
784 | Promise.longStackTraces();
785 | } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
786 | disableLongStackTraces();
787 | }
788 | }
789 | if ("warnings" in opts) {
790 | var warningsOption = opts.warnings;
791 | config.warnings = !!warningsOption;
792 | wForgottenReturn = config.warnings;
793 |
794 | if (util.isObject(warningsOption)) {
795 | if ("wForgottenReturn" in warningsOption) {
796 | wForgottenReturn = !!warningsOption.wForgottenReturn;
797 | }
798 | }
799 | }
800 | if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
801 | if (async.haveItemsQueued()) {
802 | throw new Error("cannot enable cancellation after promises are in use");
803 | }
804 | Promise.prototype._clearCancellationData = cancellationClearCancellationData;
805 | Promise.prototype._propagateFrom = cancellationPropagateFrom;
806 | Promise.prototype._onCancel = cancellationOnCancel;
807 | Promise.prototype._setOnCancel = cancellationSetOnCancel;
808 | Promise.prototype._attachCancellationCallback = cancellationAttachCancellationCallback;
809 | Promise.prototype._execute = cancellationExecute;
810 | _propagateFromFunction = cancellationPropagateFrom;
811 | config.cancellation = true;
812 | }
813 | if ("monitoring" in opts) {
814 | if (opts.monitoring && !config.monitoring) {
815 | config.monitoring = true;
816 | Promise.prototype._fireEvent = activeFireEvent;
817 | } else if (!opts.monitoring && config.monitoring) {
818 | config.monitoring = false;
819 | Promise.prototype._fireEvent = defaultFireEvent;
820 | }
821 | }
822 | };
823 |
824 | function defaultFireEvent() {
825 | return false;
826 | }
827 |
828 | Promise.prototype._fireEvent = defaultFireEvent;
829 | Promise.prototype._execute = function (executor, resolve, reject) {
830 | try {
831 | executor(resolve, reject);
832 | } catch (e) {
833 | return e;
834 | }
835 | };
836 | Promise.prototype._onCancel = function () {};
837 | Promise.prototype._setOnCancel = function (handler) {
838 | ;
839 | };
840 | Promise.prototype._attachCancellationCallback = function (onCancel) {
841 | ;
842 | };
843 | Promise.prototype._captureStackTrace = function () {};
844 | Promise.prototype._attachExtraTrace = function () {};
845 | Promise.prototype._clearCancellationData = function () {};
846 | Promise.prototype._propagateFrom = function (parent, flags) {
847 | ;
848 | ;
849 | };
850 |
851 | function cancellationExecute(executor, resolve, reject) {
852 | var promise = this;
853 | try {
854 | executor(resolve, reject, function (onCancel) {
855 | if (typeof onCancel !== "function") {
856 | throw new TypeError("onCancel must be a function, got: " + util.toString(onCancel));
857 | }
858 | promise._attachCancellationCallback(onCancel);
859 | });
860 | } catch (e) {
861 | return e;
862 | }
863 | }
864 |
865 | function cancellationAttachCancellationCallback(onCancel) {
866 | if (!this._isCancellable()) return this;
867 |
868 | var previousOnCancel = this._onCancel();
869 | if (previousOnCancel !== undefined) {
870 | if (util.isArray(previousOnCancel)) {
871 | previousOnCancel.push(onCancel);
872 | } else {
873 | this._setOnCancel([previousOnCancel, onCancel]);
874 | }
875 | } else {
876 | this._setOnCancel(onCancel);
877 | }
878 | }
879 |
880 | function cancellationOnCancel() {
881 | return this._onCancelField;
882 | }
883 |
884 | function cancellationSetOnCancel(onCancel) {
885 | this._onCancelField = onCancel;
886 | }
887 |
888 | function cancellationClearCancellationData() {
889 | this._cancellationParent = undefined;
890 | this._onCancelField = undefined;
891 | }
892 |
893 | function cancellationPropagateFrom(parent, flags) {
894 | if ((flags & 1) !== 0) {
895 | this._cancellationParent = parent;
896 | var branchesRemainingToCancel = parent._branchesRemainingToCancel;
897 | if (branchesRemainingToCancel === undefined) {
898 | branchesRemainingToCancel = 0;
899 | }
900 | parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
901 | }
902 | if ((flags & 2) !== 0 && parent._isBound()) {
903 | this._setBoundTo(parent._boundTo);
904 | }
905 | }
906 |
907 | function bindingPropagateFrom(parent, flags) {
908 | if ((flags & 2) !== 0 && parent._isBound()) {
909 | this._setBoundTo(parent._boundTo);
910 | }
911 | }
912 | var _propagateFromFunction = bindingPropagateFrom;
913 |
914 | function _boundValueFunction() {
915 | var ret = this._boundTo;
916 | if (ret !== undefined) {
917 | if (ret instanceof Promise) {
918 | if (ret.isFulfilled()) {
919 | return ret.value();
920 | } else {
921 | return undefined;
922 | }
923 | }
924 | }
925 | return ret;
926 | }
927 |
928 | function longStackTracesCaptureStackTrace() {
929 | this._trace = new CapturedTrace(this._peekContext());
930 | }
931 |
932 | function longStackTracesAttachExtraTrace(error, ignoreSelf) {
933 | if (canAttachTrace(error)) {
934 | var trace = this._trace;
935 | if (trace !== undefined) {
936 | if (ignoreSelf) trace = trace._parent;
937 | }
938 | if (trace !== undefined) {
939 | trace.attachExtraTrace(error);
940 | } else if (!error.__stackCleaned__) {
941 | var parsed = parseStackAndMessage(error);
942 | util.notEnumerableProp(error, "stack", parsed.message + "\n" + parsed.stack.join("\n"));
943 | util.notEnumerableProp(error, "__stackCleaned__", true);
944 | }
945 | }
946 | }
947 |
948 | function checkForgottenReturns(returnValue, promiseCreated, name, promise, parent) {
949 | if (returnValue === undefined && promiseCreated !== null && wForgottenReturn) {
950 | if (parent !== undefined && parent._returnedNonUndefined()) return;
951 | if ((promise._bitField & 65535) === 0) return;
952 |
953 | if (name) name = name + " ";
954 | var handlerLine = "";
955 | var creatorLine = "";
956 | if (promiseCreated._trace) {
957 | var traceLines = promiseCreated._trace.stack.split("\n");
958 | var stack = cleanStack(traceLines);
959 | for (var i = stack.length - 1; i >= 0; --i) {
960 | var line = stack[i];
961 | if (!nodeFramePattern.test(line)) {
962 | var lineMatches = line.match(parseLinePattern);
963 | if (lineMatches) {
964 | handlerLine = "at " + lineMatches[1] + ":" + lineMatches[2] + ":" + lineMatches[3] + " ";
965 | }
966 | break;
967 | }
968 | }
969 |
970 | if (stack.length > 0) {
971 | var firstUserLine = stack[0];
972 | for (var i = 0; i < traceLines.length; ++i) {
973 |
974 | if (traceLines[i] === firstUserLine) {
975 | if (i > 0) {
976 | creatorLine = "\n" + traceLines[i - 1];
977 | }
978 | break;
979 | }
980 | }
981 | }
982 | }
983 | var msg = "a promise was created in a " + name + "handler " + handlerLine + "but was not returned from it, " + "see http://goo.gl/rRqMUw" + creatorLine;
984 | promise._warn(msg, true, promiseCreated);
985 | }
986 | }
987 |
988 | function deprecated(name, replacement) {
989 | var message = name + " is deprecated and will be removed in a future version.";
990 | if (replacement) message += " Use " + replacement + " instead.";
991 | return warn(message);
992 | }
993 |
994 | function warn(message, shouldUseOwnTrace, promise) {
995 | if (!config.warnings) return;
996 | var warning = new Warning(message);
997 | var ctx;
998 | if (shouldUseOwnTrace) {
999 | promise._attachExtraTrace(warning);
1000 | } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
1001 | ctx.attachExtraTrace(warning);
1002 | } else {
1003 | var parsed = parseStackAndMessage(warning);
1004 | warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
1005 | }
1006 |
1007 | if (!activeFireEvent("warning", warning)) {
1008 | formatAndLogError(warning, "", true);
1009 | }
1010 | }
1011 |
1012 | function reconstructStack(message, stacks) {
1013 | for (var i = 0; i < stacks.length - 1; ++i) {
1014 | stacks[i].push("From previous event:");
1015 | stacks[i] = stacks[i].join("\n");
1016 | }
1017 | if (i < stacks.length) {
1018 | stacks[i] = stacks[i].join("\n");
1019 | }
1020 | return message + "\n" + stacks.join("\n");
1021 | }
1022 |
1023 | function removeDuplicateOrEmptyJumps(stacks) {
1024 | for (var i = 0; i < stacks.length; ++i) {
1025 | if (stacks[i].length === 0 || i + 1 < stacks.length && stacks[i][0] === stacks[i + 1][0]) {
1026 | stacks.splice(i, 1);
1027 | i--;
1028 | }
1029 | }
1030 | }
1031 |
1032 | function removeCommonRoots(stacks) {
1033 | var current = stacks[0];
1034 | for (var i = 1; i < stacks.length; ++i) {
1035 | var prev = stacks[i];
1036 | var currentLastIndex = current.length - 1;
1037 | var currentLastLine = current[currentLastIndex];
1038 | var commonRootMeetPoint = -1;
1039 |
1040 | for (var j = prev.length - 1; j >= 0; --j) {
1041 | if (prev[j] === currentLastLine) {
1042 | commonRootMeetPoint = j;
1043 | break;
1044 | }
1045 | }
1046 |
1047 | for (var j = commonRootMeetPoint; j >= 0; --j) {
1048 | var line = prev[j];
1049 | if (current[currentLastIndex] === line) {
1050 | current.pop();
1051 | currentLastIndex--;
1052 | } else {
1053 | break;
1054 | }
1055 | }
1056 | current = prev;
1057 | }
1058 | }
1059 |
1060 | function cleanStack(stack) {
1061 | var ret = [];
1062 | for (var i = 0; i < stack.length; ++i) {
1063 | var line = stack[i];
1064 | var isTraceLine = " (No stack trace)" === line || stackFramePattern.test(line);
1065 | var isInternalFrame = isTraceLine && shouldIgnore(line);
1066 | if (isTraceLine && !isInternalFrame) {
1067 | if (indentStackFrames && line.charAt(0) !== " ") {
1068 | line = " " + line;
1069 | }
1070 | ret.push(line);
1071 | }
1072 | }
1073 | return ret;
1074 | }
1075 |
1076 | function stackFramesAsArray(error) {
1077 | var stack = error.stack.replace(/\s+$/g, "").split("\n");
1078 | for (var i = 0; i < stack.length; ++i) {
1079 | var line = stack[i];
1080 | if (" (No stack trace)" === line || stackFramePattern.test(line)) {
1081 | break;
1082 | }
1083 | }
1084 | if (i > 0) {
1085 | stack = stack.slice(i);
1086 | }
1087 | return stack;
1088 | }
1089 |
1090 | function parseStackAndMessage(error) {
1091 | var stack = error.stack;
1092 | var message = error.toString();
1093 | stack = typeof stack === "string" && stack.length > 0 ? stackFramesAsArray(error) : [" (No stack trace)"];
1094 | return {
1095 | message: message,
1096 | stack: cleanStack(stack)
1097 | };
1098 | }
1099 |
1100 | function formatAndLogError(error, title, isSoft) {
1101 | if (typeof console !== "undefined") {
1102 | var message;
1103 | if (util.isObject(error)) {
1104 | var stack = error.stack;
1105 | message = title + formatStack(stack, error);
1106 | } else {
1107 | message = title + String(error);
1108 | }
1109 | if (typeof printWarning === "function") {
1110 | printWarning(message, isSoft);
1111 | } else if (typeof console.log === "function" || _typeof(console.log) === "object") {
1112 | console.log(message);
1113 | }
1114 | }
1115 | }
1116 |
1117 | function fireRejectionEvent(name, localHandler, reason, promise) {
1118 | var localEventFired = false;
1119 | try {
1120 | if (typeof localHandler === "function") {
1121 | localEventFired = true;
1122 | if (name === "rejectionHandled") {
1123 | localHandler(promise);
1124 | } else {
1125 | localHandler(reason, promise);
1126 | }
1127 | }
1128 | } catch (e) {
1129 | async.throwLater(e);
1130 | }
1131 |
1132 | if (name === "unhandledRejection") {
1133 | if (!activeFireEvent(name, reason, promise) && !localEventFired) {
1134 | formatAndLogError(reason, "Unhandled rejection ");
1135 | }
1136 | } else {
1137 | activeFireEvent(name, promise);
1138 | }
1139 | }
1140 |
1141 | function formatNonError(obj) {
1142 | var str;
1143 | if (typeof obj === "function") {
1144 | str = "[function " + (obj.name || "anonymous") + "]";
1145 | } else {
1146 | str = obj && typeof obj.toString === "function" ? obj.toString() : util.toString(obj);
1147 | var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
1148 | if (ruselessToString.test(str)) {
1149 | try {
1150 | var newStr = JSON.stringify(obj);
1151 | str = newStr;
1152 | } catch (e) {}
1153 | }
1154 | if (str.length === 0) {
1155 | str = "(empty array)";
1156 | }
1157 | }
1158 | return "(<" + snip(str) + ">, no stack trace)";
1159 | }
1160 |
1161 | function snip(str) {
1162 | var maxChars = 41;
1163 | if (str.length < maxChars) {
1164 | return str;
1165 | }
1166 | return str.substr(0, maxChars - 3) + "...";
1167 | }
1168 |
1169 | function longStackTracesIsSupported() {
1170 | return typeof captureStackTrace === "function";
1171 | }
1172 |
1173 | var shouldIgnore = function shouldIgnore() {
1174 | return false;
1175 | };
1176 | var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
1177 | function parseLineInfo(line) {
1178 | var matches = line.match(parseLineInfoRegex);
1179 | if (matches) {
1180 | return {
1181 | fileName: matches[1],
1182 | line: parseInt(matches[2], 10)
1183 | };
1184 | }
1185 | }
1186 |
1187 | function setBounds(firstLineError, lastLineError) {
1188 | if (!longStackTracesIsSupported()) return;
1189 | var firstStackLines = firstLineError.stack.split("\n");
1190 | var lastStackLines = lastLineError.stack.split("\n");
1191 | var firstIndex = -1;
1192 | var lastIndex = -1;
1193 | var firstFileName;
1194 | var lastFileName;
1195 | for (var i = 0; i < firstStackLines.length; ++i) {
1196 | var result = parseLineInfo(firstStackLines[i]);
1197 | if (result) {
1198 | firstFileName = result.fileName;
1199 | firstIndex = result.line;
1200 | break;
1201 | }
1202 | }
1203 | for (var i = 0; i < lastStackLines.length; ++i) {
1204 | var result = parseLineInfo(lastStackLines[i]);
1205 | if (result) {
1206 | lastFileName = result.fileName;
1207 | lastIndex = result.line;
1208 | break;
1209 | }
1210 | }
1211 | if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName || firstFileName !== lastFileName || firstIndex >= lastIndex) {
1212 | return;
1213 | }
1214 |
1215 | shouldIgnore = function shouldIgnore(line) {
1216 | if (bluebirdFramePattern.test(line)) return true;
1217 | var info = parseLineInfo(line);
1218 | if (info) {
1219 | if (info.fileName === firstFileName && firstIndex <= info.line && info.line <= lastIndex) {
1220 | return true;
1221 | }
1222 | }
1223 | return false;
1224 | };
1225 | }
1226 |
1227 | function CapturedTrace(parent) {
1228 | this._parent = parent;
1229 | this._promisesCreated = 0;
1230 | var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
1231 | captureStackTrace(this, CapturedTrace);
1232 | if (length > 32) this.uncycle();
1233 | }
1234 | util.inherits(CapturedTrace, Error);
1235 | Context.CapturedTrace = CapturedTrace;
1236 |
1237 | CapturedTrace.prototype.uncycle = function () {
1238 | var length = this._length;
1239 | if (length < 2) return;
1240 | var nodes = [];
1241 | var stackToIndex = {};
1242 |
1243 | for (var i = 0, node = this; node !== undefined; ++i) {
1244 | nodes.push(node);
1245 | node = node._parent;
1246 | }
1247 | length = this._length = i;
1248 | for (var i = length - 1; i >= 0; --i) {
1249 | var stack = nodes[i].stack;
1250 | if (stackToIndex[stack] === undefined) {
1251 | stackToIndex[stack] = i;
1252 | }
1253 | }
1254 | for (var i = 0; i < length; ++i) {
1255 | var currentStack = nodes[i].stack;
1256 | var index = stackToIndex[currentStack];
1257 | if (index !== undefined && index !== i) {
1258 | if (index > 0) {
1259 | nodes[index - 1]._parent = undefined;
1260 | nodes[index - 1]._length = 1;
1261 | }
1262 | nodes[i]._parent = undefined;
1263 | nodes[i]._length = 1;
1264 | var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
1265 |
1266 | if (index < length - 1) {
1267 | cycleEdgeNode._parent = nodes[index + 1];
1268 | cycleEdgeNode._parent.uncycle();
1269 | cycleEdgeNode._length = cycleEdgeNode._parent._length + 1;
1270 | } else {
1271 | cycleEdgeNode._parent = undefined;
1272 | cycleEdgeNode._length = 1;
1273 | }
1274 | var currentChildLength = cycleEdgeNode._length + 1;
1275 | for (var j = i - 2; j >= 0; --j) {
1276 | nodes[j]._length = currentChildLength;
1277 | currentChildLength++;
1278 | }
1279 | return;
1280 | }
1281 | }
1282 | };
1283 |
1284 | CapturedTrace.prototype.attachExtraTrace = function (error) {
1285 | if (error.__stackCleaned__) return;
1286 | this.uncycle();
1287 | var parsed = parseStackAndMessage(error);
1288 | var message = parsed.message;
1289 | var stacks = [parsed.stack];
1290 |
1291 | var trace = this;
1292 | while (trace !== undefined) {
1293 | stacks.push(cleanStack(trace.stack.split("\n")));
1294 | trace = trace._parent;
1295 | }
1296 | removeCommonRoots(stacks);
1297 | removeDuplicateOrEmptyJumps(stacks);
1298 | util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
1299 | util.notEnumerableProp(error, "__stackCleaned__", true);
1300 | };
1301 |
1302 | var captureStackTrace = function stackDetection() {
1303 | var v8stackFramePattern = /^\s*at\s*/;
1304 | var v8stackFormatter = function v8stackFormatter(stack, error) {
1305 | if (typeof stack === "string") return stack;
1306 |
1307 | if (error.name !== undefined && error.message !== undefined) {
1308 | return error.toString();
1309 | }
1310 | return formatNonError(error);
1311 | };
1312 |
1313 | if (typeof Error.stackTraceLimit === "number" && typeof Error.captureStackTrace === "function") {
1314 | Error.stackTraceLimit += 6;
1315 | stackFramePattern = v8stackFramePattern;
1316 | formatStack = v8stackFormatter;
1317 | var captureStackTrace = Error.captureStackTrace;
1318 |
1319 | shouldIgnore = function shouldIgnore(line) {
1320 | return bluebirdFramePattern.test(line);
1321 | };
1322 | return function (receiver, ignoreUntil) {
1323 | Error.stackTraceLimit += 6;
1324 | captureStackTrace(receiver, ignoreUntil);
1325 | Error.stackTraceLimit -= 6;
1326 | };
1327 | }
1328 | var err = new Error();
1329 |
1330 | if (typeof err.stack === "string" && err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
1331 | stackFramePattern = /@/;
1332 | formatStack = v8stackFormatter;
1333 | indentStackFrames = true;
1334 | return function captureStackTrace(o) {
1335 | o.stack = new Error().stack;
1336 | };
1337 | }
1338 |
1339 | var hasStackAfterThrow;
1340 | try {
1341 | throw new Error();
1342 | } catch (e) {
1343 | hasStackAfterThrow = "stack" in e;
1344 | }
1345 | if (!("stack" in err) && hasStackAfterThrow && typeof Error.stackTraceLimit === "number") {
1346 | stackFramePattern = v8stackFramePattern;
1347 | formatStack = v8stackFormatter;
1348 | return function captureStackTrace(o) {
1349 | Error.stackTraceLimit += 6;
1350 | try {
1351 | throw new Error();
1352 | } catch (e) {
1353 | o.stack = e.stack;
1354 | }
1355 | Error.stackTraceLimit -= 6;
1356 | };
1357 | }
1358 |
1359 | formatStack = function formatStack(stack, error) {
1360 | if (typeof stack === "string") return stack;
1361 |
1362 | if (((typeof error === "undefined" ? "undefined" : _typeof(error)) === "object" || typeof error === "function") && error.name !== undefined && error.message !== undefined) {
1363 | return error.toString();
1364 | }
1365 | return formatNonError(error);
1366 | };
1367 |
1368 | return null;
1369 | }([]);
1370 |
1371 | if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
1372 | printWarning = function printWarning(message) {
1373 | console.warn(message);
1374 | };
1375 | if (util.isNode && process.stderr.isTTY) {
1376 | printWarning = function printWarning(message, isSoft) {
1377 | var color = isSoft ? "\x1B[33m" : "\x1B[31m";
1378 | console.warn(color + message + "\x1B[0m\n");
1379 | };
1380 | } else if (!util.isNode && typeof new Error().stack === "string") {
1381 | printWarning = function printWarning(message, isSoft) {
1382 | console.warn("%c" + message, isSoft ? "color: darkorange" : "color: red");
1383 | };
1384 | }
1385 | }
1386 |
1387 | var config = {
1388 | warnings: warnings,
1389 | longStackTraces: false,
1390 | cancellation: false,
1391 | monitoring: false
1392 | };
1393 |
1394 | if (longStackTraces) Promise.longStackTraces();
1395 |
1396 | return {
1397 | longStackTraces: function longStackTraces() {
1398 | return config.longStackTraces;
1399 | },
1400 | warnings: function warnings() {
1401 | return config.warnings;
1402 | },
1403 | cancellation: function cancellation() {
1404 | return config.cancellation;
1405 | },
1406 | monitoring: function monitoring() {
1407 | return config.monitoring;
1408 | },
1409 | propagateFromFunction: function propagateFromFunction() {
1410 | return _propagateFromFunction;
1411 | },
1412 | boundValueFunction: function boundValueFunction() {
1413 | return _boundValueFunction;
1414 | },
1415 | checkForgottenReturns: checkForgottenReturns,
1416 | setBounds: setBounds,
1417 | warn: warn,
1418 | deprecated: deprecated,
1419 | CapturedTrace: CapturedTrace,
1420 | fireDomEvent: fireDomEvent,
1421 | fireGlobalEvent: fireGlobalEvent
1422 | };
1423 | };
1424 | }, { "./errors": 9, "./util": 21 }], 8: [function (_dereq_, module, exports) {
1425 | "use strict";
1426 |
1427 | module.exports = function (Promise) {
1428 | function returner() {
1429 | return this.value;
1430 | }
1431 | function thrower() {
1432 | throw this.reason;
1433 | }
1434 |
1435 | Promise.prototype["return"] = Promise.prototype.thenReturn = function (value) {
1436 | if (value instanceof Promise) value.suppressUnhandledRejections();
1437 | return this._then(returner, undefined, undefined, { value: value }, undefined);
1438 | };
1439 |
1440 | Promise.prototype["throw"] = Promise.prototype.thenThrow = function (reason) {
1441 | return this._then(thrower, undefined, undefined, { reason: reason }, undefined);
1442 | };
1443 |
1444 | Promise.prototype.catchThrow = function (reason) {
1445 | if (arguments.length <= 1) {
1446 | return this._then(undefined, thrower, undefined, { reason: reason }, undefined);
1447 | } else {
1448 | var _reason = arguments[1];
1449 | var handler = function handler() {
1450 | throw _reason;
1451 | };
1452 | return this.caught(reason, handler);
1453 | }
1454 | };
1455 |
1456 | Promise.prototype.catchReturn = function (value) {
1457 | if (arguments.length <= 1) {
1458 | if (value instanceof Promise) value.suppressUnhandledRejections();
1459 | return this._then(undefined, returner, undefined, { value: value }, undefined);
1460 | } else {
1461 | var _value = arguments[1];
1462 | if (_value instanceof Promise) _value.suppressUnhandledRejections();
1463 | var handler = function handler() {
1464 | return _value;
1465 | };
1466 | return this.caught(value, handler);
1467 | }
1468 | };
1469 | };
1470 | }, {}], 9: [function (_dereq_, module, exports) {
1471 | "use strict";
1472 |
1473 | var es5 = _dereq_("./es5");
1474 | var Objectfreeze = es5.freeze;
1475 | var util = _dereq_("./util");
1476 | var inherits = util.inherits;
1477 | var notEnumerableProp = util.notEnumerableProp;
1478 |
1479 | function subError(nameProperty, defaultMessage) {
1480 | function SubError(message) {
1481 | if (!(this instanceof SubError)) return new SubError(message);
1482 | notEnumerableProp(this, "message", typeof message === "string" ? message : defaultMessage);
1483 | notEnumerableProp(this, "name", nameProperty);
1484 | if (Error.captureStackTrace) {
1485 | Error.captureStackTrace(this, this.constructor);
1486 | } else {
1487 | Error.call(this);
1488 | }
1489 | }
1490 | inherits(SubError, Error);
1491 | return SubError;
1492 | }
1493 |
1494 | var _TypeError, _RangeError;
1495 | var Warning = subError("Warning", "warning");
1496 | var CancellationError = subError("CancellationError", "cancellation error");
1497 | var TimeoutError = subError("TimeoutError", "timeout error");
1498 | var AggregateError = subError("AggregateError", "aggregate error");
1499 | try {
1500 | _TypeError = TypeError;
1501 | _RangeError = RangeError;
1502 | } catch (e) {
1503 | _TypeError = subError("TypeError", "type error");
1504 | _RangeError = subError("RangeError", "range error");
1505 | }
1506 |
1507 | var methods = ("join pop push shift unshift slice filter forEach some " + "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
1508 |
1509 | for (var i = 0; i < methods.length; ++i) {
1510 | if (typeof Array.prototype[methods[i]] === "function") {
1511 | AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
1512 | }
1513 | }
1514 |
1515 | es5.defineProperty(AggregateError.prototype, "length", {
1516 | value: 0,
1517 | configurable: false,
1518 | writable: true,
1519 | enumerable: true
1520 | });
1521 | AggregateError.prototype["isOperational"] = true;
1522 | var level = 0;
1523 | AggregateError.prototype.toString = function () {
1524 | var indent = Array(level * 4 + 1).join(" ");
1525 | var ret = "\n" + indent + "AggregateError of:" + "\n";
1526 | level++;
1527 | indent = Array(level * 4 + 1).join(" ");
1528 | for (var i = 0; i < this.length; ++i) {
1529 | var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
1530 | var lines = str.split("\n");
1531 | for (var j = 0; j < lines.length; ++j) {
1532 | lines[j] = indent + lines[j];
1533 | }
1534 | str = lines.join("\n");
1535 | ret += str + "\n";
1536 | }
1537 | level--;
1538 | return ret;
1539 | };
1540 |
1541 | function OperationalError(message) {
1542 | if (!(this instanceof OperationalError)) return new OperationalError(message);
1543 | notEnumerableProp(this, "name", "OperationalError");
1544 | notEnumerableProp(this, "message", message);
1545 | this.cause = message;
1546 | this["isOperational"] = true;
1547 |
1548 | if (message instanceof Error) {
1549 | notEnumerableProp(this, "message", message.message);
1550 | notEnumerableProp(this, "stack", message.stack);
1551 | } else if (Error.captureStackTrace) {
1552 | Error.captureStackTrace(this, this.constructor);
1553 | }
1554 | }
1555 | inherits(OperationalError, Error);
1556 |
1557 | var errorTypes = Error["__BluebirdErrorTypes__"];
1558 | if (!errorTypes) {
1559 | errorTypes = Objectfreeze({
1560 | CancellationError: CancellationError,
1561 | TimeoutError: TimeoutError,
1562 | OperationalError: OperationalError,
1563 | RejectionError: OperationalError,
1564 | AggregateError: AggregateError
1565 | });
1566 | es5.defineProperty(Error, "__BluebirdErrorTypes__", {
1567 | value: errorTypes,
1568 | writable: false,
1569 | enumerable: false,
1570 | configurable: false
1571 | });
1572 | }
1573 |
1574 | module.exports = {
1575 | Error: Error,
1576 | TypeError: _TypeError,
1577 | RangeError: _RangeError,
1578 | CancellationError: errorTypes.CancellationError,
1579 | OperationalError: errorTypes.OperationalError,
1580 | TimeoutError: errorTypes.TimeoutError,
1581 | AggregateError: errorTypes.AggregateError,
1582 | Warning: Warning
1583 | };
1584 | }, { "./es5": 10, "./util": 21 }], 10: [function (_dereq_, module, exports) {
1585 | var isES5 = function () {
1586 | "use strict";
1587 |
1588 | return this === undefined;
1589 | }();
1590 |
1591 | if (isES5) {
1592 | module.exports = {
1593 | freeze: Object.freeze,
1594 | defineProperty: Object.defineProperty,
1595 | getDescriptor: Object.getOwnPropertyDescriptor,
1596 | keys: Object.keys,
1597 | names: Object.getOwnPropertyNames,
1598 | getPrototypeOf: Object.getPrototypeOf,
1599 | isArray: Array.isArray,
1600 | isES5: isES5,
1601 | propertyIsWritable: function propertyIsWritable(obj, prop) {
1602 | var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
1603 | return !!(!descriptor || descriptor.writable || descriptor.set);
1604 | }
1605 | };
1606 | } else {
1607 | var has = {}.hasOwnProperty;
1608 | var str = {}.toString;
1609 | var proto = {}.constructor.prototype;
1610 |
1611 | var ObjectKeys = function ObjectKeys(o) {
1612 | var ret = [];
1613 | for (var key in o) {
1614 | if (has.call(o, key)) {
1615 | ret.push(key);
1616 | }
1617 | }
1618 | return ret;
1619 | };
1620 |
1621 | var ObjectGetDescriptor = function ObjectGetDescriptor(o, key) {
1622 | return { value: o[key] };
1623 | };
1624 |
1625 | var ObjectDefineProperty = function ObjectDefineProperty(o, key, desc) {
1626 | o[key] = desc.value;
1627 | return o;
1628 | };
1629 |
1630 | var ObjectFreeze = function ObjectFreeze(obj) {
1631 | return obj;
1632 | };
1633 |
1634 | var ObjectGetPrototypeOf = function ObjectGetPrototypeOf(obj) {
1635 | try {
1636 | return Object(obj).constructor.prototype;
1637 | } catch (e) {
1638 | return proto;
1639 | }
1640 | };
1641 |
1642 | var ArrayIsArray = function ArrayIsArray(obj) {
1643 | try {
1644 | return str.call(obj) === "[object Array]";
1645 | } catch (e) {
1646 | return false;
1647 | }
1648 | };
1649 |
1650 | module.exports = {
1651 | isArray: ArrayIsArray,
1652 | keys: ObjectKeys,
1653 | names: ObjectKeys,
1654 | defineProperty: ObjectDefineProperty,
1655 | getDescriptor: ObjectGetDescriptor,
1656 | freeze: ObjectFreeze,
1657 | getPrototypeOf: ObjectGetPrototypeOf,
1658 | isES5: isES5,
1659 | propertyIsWritable: function propertyIsWritable() {
1660 | return true;
1661 | }
1662 | };
1663 | }
1664 | }, {}], 11: [function (_dereq_, module, exports) {
1665 | "use strict";
1666 |
1667 | module.exports = function (Promise, tryConvertToPromise) {
1668 | var util = _dereq_("./util");
1669 | var CancellationError = Promise.CancellationError;
1670 | var errorObj = util.errorObj;
1671 |
1672 | function PassThroughHandlerContext(promise, type, handler) {
1673 | this.promise = promise;
1674 | this.type = type;
1675 | this.handler = handler;
1676 | this.called = false;
1677 | this.cancelPromise = null;
1678 | }
1679 |
1680 | PassThroughHandlerContext.prototype.isFinallyHandler = function () {
1681 | return this.type === 0;
1682 | };
1683 |
1684 | function FinallyHandlerCancelReaction(finallyHandler) {
1685 | this.finallyHandler = finallyHandler;
1686 | }
1687 |
1688 | FinallyHandlerCancelReaction.prototype._resultCancelled = function () {
1689 | checkCancel(this.finallyHandler);
1690 | };
1691 |
1692 | function checkCancel(ctx, reason) {
1693 | if (ctx.cancelPromise != null) {
1694 | if (arguments.length > 1) {
1695 | ctx.cancelPromise._reject(reason);
1696 | } else {
1697 | ctx.cancelPromise._cancel();
1698 | }
1699 | ctx.cancelPromise = null;
1700 | return true;
1701 | }
1702 | return false;
1703 | }
1704 |
1705 | function succeed() {
1706 | return finallyHandler.call(this, this.promise._target()._settledValue());
1707 | }
1708 | function fail(reason) {
1709 | if (checkCancel(this, reason)) return;
1710 | errorObj.e = reason;
1711 | return errorObj;
1712 | }
1713 | function finallyHandler(reasonOrValue) {
1714 | var promise = this.promise;
1715 | var handler = this.handler;
1716 |
1717 | if (!this.called) {
1718 | this.called = true;
1719 | var ret = this.isFinallyHandler() ? handler.call(promise._boundValue()) : handler.call(promise._boundValue(), reasonOrValue);
1720 | if (ret !== undefined) {
1721 | promise._setReturnedNonUndefined();
1722 | var maybePromise = tryConvertToPromise(ret, promise);
1723 | if (maybePromise instanceof Promise) {
1724 | if (this.cancelPromise != null) {
1725 | if (maybePromise._isCancelled()) {
1726 | var reason = new CancellationError("late cancellation observer");
1727 | promise._attachExtraTrace(reason);
1728 | errorObj.e = reason;
1729 | return errorObj;
1730 | } else if (maybePromise.isPending()) {
1731 | maybePromise._attachCancellationCallback(new FinallyHandlerCancelReaction(this));
1732 | }
1733 | }
1734 | return maybePromise._then(succeed, fail, undefined, this, undefined);
1735 | }
1736 | }
1737 | }
1738 |
1739 | if (promise.isRejected()) {
1740 | checkCancel(this);
1741 | errorObj.e = reasonOrValue;
1742 | return errorObj;
1743 | } else {
1744 | checkCancel(this);
1745 | return reasonOrValue;
1746 | }
1747 | }
1748 |
1749 | Promise.prototype._passThrough = function (handler, type, success, fail) {
1750 | if (typeof handler !== "function") return this.then();
1751 | return this._then(success, fail, undefined, new PassThroughHandlerContext(this, type, handler), undefined);
1752 | };
1753 |
1754 | Promise.prototype.lastly = Promise.prototype["finally"] = function (handler) {
1755 | return this._passThrough(handler, 0, finallyHandler, finallyHandler);
1756 | };
1757 |
1758 | Promise.prototype.tap = function (handler) {
1759 | return this._passThrough(handler, 1, finallyHandler);
1760 | };
1761 |
1762 | return PassThroughHandlerContext;
1763 | };
1764 | }, { "./util": 21 }], 12: [function (_dereq_, module, exports) {
1765 | "use strict";
1766 |
1767 | module.exports = function (Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain) {
1768 | var util = _dereq_("./util");
1769 | var canEvaluate = util.canEvaluate;
1770 | var tryCatch = util.tryCatch;
1771 | var errorObj = util.errorObj;
1772 | var reject;
1773 |
1774 | if (!true) {
1775 | if (canEvaluate) {
1776 | var thenCallback = function thenCallback(i) {
1777 | return new Function("value", "holder", " \n\
1778 | 'use strict'; \n\
1779 | holder.pIndex = value; \n\
1780 | holder.checkFulfillment(this); \n\
1781 | ".replace(/Index/g, i));
1782 | };
1783 |
1784 | var promiseSetter = function promiseSetter(i) {
1785 | return new Function("promise", "holder", " \n\
1786 | 'use strict'; \n\
1787 | holder.pIndex = promise; \n\
1788 | ".replace(/Index/g, i));
1789 | };
1790 |
1791 | var generateHolderClass = function generateHolderClass(total) {
1792 | var props = new Array(total);
1793 | for (var i = 0; i < props.length; ++i) {
1794 | props[i] = "this.p" + (i + 1);
1795 | }
1796 | var assignment = props.join(" = ") + " = null;";
1797 | var cancellationCode = "var promise;\n" + props.map(function (prop) {
1798 | return " \n\
1799 | promise = " + prop + "; \n\
1800 | if (promise instanceof Promise) { \n\
1801 | promise.cancel(); \n\
1802 | } \n\
1803 | ";
1804 | }).join("\n");
1805 | var passedArguments = props.join(", ");
1806 | var name = "Holder$" + total;
1807 |
1808 | var code = "return function(tryCatch, errorObj, Promise, async) { \n\
1809 | 'use strict'; \n\
1810 | function [TheName](fn) { \n\
1811 | [TheProperties] \n\
1812 | this.fn = fn; \n\
1813 | this.asyncNeeded = true; \n\
1814 | this.now = 0; \n\
1815 | } \n\
1816 | \n\
1817 | [TheName].prototype._callFunction = function(promise) { \n\
1818 | promise._pushContext(); \n\
1819 | var ret = tryCatch(this.fn)([ThePassedArguments]); \n\
1820 | promise._popContext(); \n\
1821 | if (ret === errorObj) { \n\
1822 | promise._rejectCallback(ret.e, false); \n\
1823 | } else { \n\
1824 | promise._resolveCallback(ret); \n\
1825 | } \n\
1826 | }; \n\
1827 | \n\
1828 | [TheName].prototype.checkFulfillment = function(promise) { \n\
1829 | var now = ++this.now; \n\
1830 | if (now === [TheTotal]) { \n\
1831 | if (this.asyncNeeded) { \n\
1832 | async.invoke(this._callFunction, this, promise); \n\
1833 | } else { \n\
1834 | this._callFunction(promise); \n\
1835 | } \n\
1836 | \n\
1837 | } \n\
1838 | }; \n\
1839 | \n\
1840 | [TheName].prototype._resultCancelled = function() { \n\
1841 | [CancellationCode] \n\
1842 | }; \n\
1843 | \n\
1844 | return [TheName]; \n\
1845 | }(tryCatch, errorObj, Promise, async); \n\
1846 | ";
1847 |
1848 | code = code.replace(/\[TheName\]/g, name).replace(/\[TheTotal\]/g, total).replace(/\[ThePassedArguments\]/g, passedArguments).replace(/\[TheProperties\]/g, assignment).replace(/\[CancellationCode\]/g, cancellationCode);
1849 |
1850 | return new Function("tryCatch", "errorObj", "Promise", "async", code)(tryCatch, errorObj, Promise, async);
1851 | };
1852 |
1853 | var holderClasses = [];
1854 | var thenCallbacks = [];
1855 | var promiseSetters = [];
1856 |
1857 | for (var i = 0; i < 8; ++i) {
1858 | holderClasses.push(generateHolderClass(i + 1));
1859 | thenCallbacks.push(thenCallback(i + 1));
1860 | promiseSetters.push(promiseSetter(i + 1));
1861 | }
1862 |
1863 | reject = function reject(reason) {
1864 | this._reject(reason);
1865 | };
1866 | }
1867 | }
1868 |
1869 | Promise.join = function () {
1870 | var last = arguments.length - 1;
1871 | var fn;
1872 | if (last > 0 && typeof arguments[last] === "function") {
1873 | fn = arguments[last];
1874 | if (!true) {
1875 | if (last <= 8 && canEvaluate) {
1876 | var ret = new Promise(INTERNAL);
1877 | ret._captureStackTrace();
1878 | var HolderClass = holderClasses[last - 1];
1879 | var holder = new HolderClass(fn);
1880 | var callbacks = thenCallbacks;
1881 |
1882 | for (var i = 0; i < last; ++i) {
1883 | var maybePromise = tryConvertToPromise(arguments[i], ret);
1884 | if (maybePromise instanceof Promise) {
1885 | maybePromise = maybePromise._target();
1886 | var bitField = maybePromise._bitField;
1887 | ;
1888 | if ((bitField & 50397184) === 0) {
1889 | maybePromise._then(callbacks[i], reject, undefined, ret, holder);
1890 | promiseSetters[i](maybePromise, holder);
1891 | holder.asyncNeeded = false;
1892 | } else if ((bitField & 33554432) !== 0) {
1893 | callbacks[i].call(ret, maybePromise._value(), holder);
1894 | } else if ((bitField & 16777216) !== 0) {
1895 | ret._reject(maybePromise._reason());
1896 | } else {
1897 | ret._cancel();
1898 | }
1899 | } else {
1900 | callbacks[i].call(ret, maybePromise, holder);
1901 | }
1902 | }
1903 |
1904 | if (!ret._isFateSealed()) {
1905 | if (holder.asyncNeeded) {
1906 | var domain = getDomain();
1907 | if (domain !== null) {
1908 | holder.fn = util.domainBind(domain, holder.fn);
1909 | }
1910 | }
1911 | ret._setAsyncGuaranteed();
1912 | ret._setOnCancel(holder);
1913 | }
1914 | return ret;
1915 | }
1916 | }
1917 | }
1918 | var args = [].slice.call(arguments);;
1919 | if (fn) args.pop();
1920 | var ret = new PromiseArray(args).promise();
1921 | return fn !== undefined ? ret.spread(fn) : ret;
1922 | };
1923 | };
1924 | }, { "./util": 21 }], 13: [function (_dereq_, module, exports) {
1925 | "use strict";
1926 |
1927 | module.exports = function (Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
1928 | var util = _dereq_("./util");
1929 | var tryCatch = util.tryCatch;
1930 |
1931 | Promise.method = function (fn) {
1932 | if (typeof fn !== "function") {
1933 | throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
1934 | }
1935 | return function () {
1936 | var ret = new Promise(INTERNAL);
1937 | ret._captureStackTrace();
1938 | ret._pushContext();
1939 | var value = tryCatch(fn).apply(this, arguments);
1940 | var promiseCreated = ret._popContext();
1941 | debug.checkForgottenReturns(value, promiseCreated, "Promise.method", ret);
1942 | ret._resolveFromSyncValue(value);
1943 | return ret;
1944 | };
1945 | };
1946 |
1947 | Promise.attempt = Promise["try"] = function (fn) {
1948 | if (typeof fn !== "function") {
1949 | return apiRejection("expecting a function but got " + util.classString(fn));
1950 | }
1951 | var ret = new Promise(INTERNAL);
1952 | ret._captureStackTrace();
1953 | ret._pushContext();
1954 | var value;
1955 | if (arguments.length > 1) {
1956 | debug.deprecated("calling Promise.try with more than 1 argument");
1957 | var arg = arguments[1];
1958 | var ctx = arguments[2];
1959 | value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg) : tryCatch(fn).call(ctx, arg);
1960 | } else {
1961 | value = tryCatch(fn)();
1962 | }
1963 | var promiseCreated = ret._popContext();
1964 | debug.checkForgottenReturns(value, promiseCreated, "Promise.try", ret);
1965 | ret._resolveFromSyncValue(value);
1966 | return ret;
1967 | };
1968 |
1969 | Promise.prototype._resolveFromSyncValue = function (value) {
1970 | if (value === util.errorObj) {
1971 | this._rejectCallback(value.e, false);
1972 | } else {
1973 | this._resolveCallback(value, true);
1974 | }
1975 | };
1976 | };
1977 | }, { "./util": 21 }], 14: [function (_dereq_, module, exports) {
1978 | "use strict";
1979 |
1980 | var util = _dereq_("./util");
1981 | var maybeWrapAsError = util.maybeWrapAsError;
1982 | var errors = _dereq_("./errors");
1983 | var OperationalError = errors.OperationalError;
1984 | var es5 = _dereq_("./es5");
1985 |
1986 | function isUntypedError(obj) {
1987 | return obj instanceof Error && es5.getPrototypeOf(obj) === Error.prototype;
1988 | }
1989 |
1990 | var rErrorKey = /^(?:name|message|stack|cause)$/;
1991 | function wrapAsOperationalError(obj) {
1992 | var ret;
1993 | if (isUntypedError(obj)) {
1994 | ret = new OperationalError(obj);
1995 | ret.name = obj.name;
1996 | ret.message = obj.message;
1997 | ret.stack = obj.stack;
1998 | var keys = es5.keys(obj);
1999 | for (var i = 0; i < keys.length; ++i) {
2000 | var key = keys[i];
2001 | if (!rErrorKey.test(key)) {
2002 | ret[key] = obj[key];
2003 | }
2004 | }
2005 | return ret;
2006 | }
2007 | util.markAsOriginatingFromRejection(obj);
2008 | return obj;
2009 | }
2010 |
2011 | function nodebackForPromise(promise, multiArgs) {
2012 | return function (err, value) {
2013 | if (promise === null) return;
2014 | if (err) {
2015 | var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
2016 | promise._attachExtraTrace(wrapped);
2017 | promise._reject(wrapped);
2018 | } else if (!multiArgs) {
2019 | promise._fulfill(value);
2020 | } else {
2021 | var args = [].slice.call(arguments, 1);;
2022 | promise._fulfill(args);
2023 | }
2024 | promise = null;
2025 | };
2026 | }
2027 |
2028 | module.exports = nodebackForPromise;
2029 | }, { "./errors": 9, "./es5": 10, "./util": 21 }], 15: [function (_dereq_, module, exports) {
2030 | "use strict";
2031 |
2032 | module.exports = function () {
2033 | var makeSelfResolutionError = function makeSelfResolutionError() {
2034 | return new TypeError("circular promise resolution chain\n\n See http://goo.gl/MqrFmX\n");
2035 | };
2036 | var reflectHandler = function reflectHandler() {
2037 | return new Promise.PromiseInspection(this._target());
2038 | };
2039 | var apiRejection = function apiRejection(msg) {
2040 | return Promise.reject(new TypeError(msg));
2041 | };
2042 | function Proxyable() {}
2043 | var UNDEFINED_BINDING = {};
2044 | var util = _dereq_("./util");
2045 |
2046 | var getDomain;
2047 | if (util.isNode) {
2048 | getDomain = function getDomain() {
2049 | var ret = process.domain;
2050 | if (ret === undefined) ret = null;
2051 | return ret;
2052 | };
2053 | } else {
2054 | getDomain = function getDomain() {
2055 | return null;
2056 | };
2057 | }
2058 | util.notEnumerableProp(Promise, "_getDomain", getDomain);
2059 |
2060 | var es5 = _dereq_("./es5");
2061 | var Async = _dereq_("./async");
2062 | var async = new Async();
2063 | es5.defineProperty(Promise, "_async", { value: async });
2064 | var errors = _dereq_("./errors");
2065 | var TypeError = Promise.TypeError = errors.TypeError;
2066 | Promise.RangeError = errors.RangeError;
2067 | var CancellationError = Promise.CancellationError = errors.CancellationError;
2068 | Promise.TimeoutError = errors.TimeoutError;
2069 | Promise.OperationalError = errors.OperationalError;
2070 | Promise.RejectionError = errors.OperationalError;
2071 | Promise.AggregateError = errors.AggregateError;
2072 | var INTERNAL = function INTERNAL() {};
2073 | var APPLY = {};
2074 | var NEXT_FILTER = {};
2075 | var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL);
2076 | var PromiseArray = _dereq_("./promise_array")(Promise, INTERNAL, tryConvertToPromise, apiRejection, Proxyable);
2077 | var Context = _dereq_("./context")(Promise);
2078 | /*jshint unused:false*/
2079 | var createContext = Context.create;
2080 | var debug = _dereq_("./debuggability")(Promise, Context);
2081 | var CapturedTrace = debug.CapturedTrace;
2082 | var PassThroughHandlerContext = _dereq_("./finally")(Promise, tryConvertToPromise);
2083 | var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
2084 | var nodebackForPromise = _dereq_("./nodeback");
2085 | var errorObj = util.errorObj;
2086 | var tryCatch = util.tryCatch;
2087 | function check(self, executor) {
2088 | if (typeof executor !== "function") {
2089 | throw new TypeError("expecting a function but got " + util.classString(executor));
2090 | }
2091 | if (self.constructor !== Promise) {
2092 | throw new TypeError("the promise constructor cannot be invoked directly\n\n See http://goo.gl/MqrFmX\n");
2093 | }
2094 | }
2095 |
2096 | function Promise(executor) {
2097 | this._bitField = 0;
2098 | this._fulfillmentHandler0 = undefined;
2099 | this._rejectionHandler0 = undefined;
2100 | this._promise0 = undefined;
2101 | this._receiver0 = undefined;
2102 | if (executor !== INTERNAL) {
2103 | check(this, executor);
2104 | this._resolveFromExecutor(executor);
2105 | }
2106 | this._promiseCreated();
2107 | this._fireEvent("promiseCreated", this);
2108 | }
2109 |
2110 | Promise.prototype.toString = function () {
2111 | return "[object Promise]";
2112 | };
2113 |
2114 | Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
2115 | var len = arguments.length;
2116 | if (len > 1) {
2117 | var catchInstances = new Array(len - 1),
2118 | j = 0,
2119 | i;
2120 | for (i = 0; i < len - 1; ++i) {
2121 | var item = arguments[i];
2122 | if (util.isObject(item)) {
2123 | catchInstances[j++] = item;
2124 | } else {
2125 | return apiRejection("expecting an object but got " + "A catch statement predicate " + util.classString(item));
2126 | }
2127 | }
2128 | catchInstances.length = j;
2129 | fn = arguments[i];
2130 | return this.then(undefined, catchFilter(catchInstances, fn, this));
2131 | }
2132 | return this.then(undefined, fn);
2133 | };
2134 |
2135 | Promise.prototype.reflect = function () {
2136 | return this._then(reflectHandler, reflectHandler, undefined, this, undefined);
2137 | };
2138 |
2139 | Promise.prototype.then = function (didFulfill, didReject) {
2140 | if (debug.warnings() && arguments.length > 0 && typeof didFulfill !== "function" && typeof didReject !== "function") {
2141 | var msg = ".then() only accepts functions but was passed: " + util.classString(didFulfill);
2142 | if (arguments.length > 1) {
2143 | msg += ", " + util.classString(didReject);
2144 | }
2145 | this._warn(msg);
2146 | }
2147 | return this._then(didFulfill, didReject, undefined, undefined, undefined);
2148 | };
2149 |
2150 | Promise.prototype.done = function (didFulfill, didReject) {
2151 | var promise = this._then(didFulfill, didReject, undefined, undefined, undefined);
2152 | promise._setIsFinal();
2153 | };
2154 |
2155 | Promise.prototype.spread = function (fn) {
2156 | if (typeof fn !== "function") {
2157 | return apiRejection("expecting a function but got " + util.classString(fn));
2158 | }
2159 | return this.all()._then(fn, undefined, undefined, APPLY, undefined);
2160 | };
2161 |
2162 | Promise.prototype.toJSON = function () {
2163 | var ret = {
2164 | isFulfilled: false,
2165 | isRejected: false,
2166 | fulfillmentValue: undefined,
2167 | rejectionReason: undefined
2168 | };
2169 | if (this.isFulfilled()) {
2170 | ret.fulfillmentValue = this.value();
2171 | ret.isFulfilled = true;
2172 | } else if (this.isRejected()) {
2173 | ret.rejectionReason = this.reason();
2174 | ret.isRejected = true;
2175 | }
2176 | return ret;
2177 | };
2178 |
2179 | Promise.prototype.all = function () {
2180 | if (arguments.length > 0) {
2181 | this._warn(".all() was passed arguments but it does not take any");
2182 | }
2183 | return new PromiseArray(this).promise();
2184 | };
2185 |
2186 | Promise.prototype.error = function (fn) {
2187 | return this.caught(util.originatesFromRejection, fn);
2188 | };
2189 |
2190 | Promise.getNewLibraryCopy = module.exports;
2191 |
2192 | Promise.is = function (val) {
2193 | return val instanceof Promise;
2194 | };
2195 |
2196 | Promise.fromNode = Promise.fromCallback = function (fn) {
2197 | var ret = new Promise(INTERNAL);
2198 | ret._captureStackTrace();
2199 | var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs : false;
2200 | var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
2201 | if (result === errorObj) {
2202 | ret._rejectCallback(result.e, true);
2203 | }
2204 | if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
2205 | return ret;
2206 | };
2207 |
2208 | Promise.all = function (promises) {
2209 | return new PromiseArray(promises).promise();
2210 | };
2211 |
2212 | Promise.cast = function (obj) {
2213 | var ret = tryConvertToPromise(obj);
2214 | if (!(ret instanceof Promise)) {
2215 | ret = new Promise(INTERNAL);
2216 | ret._captureStackTrace();
2217 | ret._setFulfilled();
2218 | ret._rejectionHandler0 = obj;
2219 | }
2220 | return ret;
2221 | };
2222 |
2223 | Promise.resolve = Promise.fulfilled = Promise.cast;
2224 |
2225 | Promise.reject = Promise.rejected = function (reason) {
2226 | var ret = new Promise(INTERNAL);
2227 | ret._captureStackTrace();
2228 | ret._rejectCallback(reason, true);
2229 | return ret;
2230 | };
2231 |
2232 | Promise.setScheduler = function (fn) {
2233 | if (typeof fn !== "function") {
2234 | throw new TypeError("expecting a function but got " + util.classString(fn));
2235 | }
2236 | return async.setScheduler(fn);
2237 | };
2238 |
2239 | Promise.prototype._then = function (didFulfill, didReject, _, receiver, internalData) {
2240 | var haveInternalData = internalData !== undefined;
2241 | var promise = haveInternalData ? internalData : new Promise(INTERNAL);
2242 | var target = this._target();
2243 | var bitField = target._bitField;
2244 |
2245 | if (!haveInternalData) {
2246 | promise._propagateFrom(this, 3);
2247 | promise._captureStackTrace();
2248 | if (receiver === undefined && (this._bitField & 2097152) !== 0) {
2249 | if (!((bitField & 50397184) === 0)) {
2250 | receiver = this._boundValue();
2251 | } else {
2252 | receiver = target === this ? undefined : this._boundTo;
2253 | }
2254 | }
2255 | this._fireEvent("promiseChained", this, promise);
2256 | }
2257 |
2258 | var domain = getDomain();
2259 | if (!((bitField & 50397184) === 0)) {
2260 | var handler,
2261 | value,
2262 | settler = target._settlePromiseCtx;
2263 | if ((bitField & 33554432) !== 0) {
2264 | value = target._rejectionHandler0;
2265 | handler = didFulfill;
2266 | } else if ((bitField & 16777216) !== 0) {
2267 | value = target._fulfillmentHandler0;
2268 | handler = didReject;
2269 | target._unsetRejectionIsUnhandled();
2270 | } else {
2271 | settler = target._settlePromiseLateCancellationObserver;
2272 | value = new CancellationError("late cancellation observer");
2273 | target._attachExtraTrace(value);
2274 | handler = didReject;
2275 | }
2276 |
2277 | async.invoke(settler, target, {
2278 | handler: domain === null ? handler : typeof handler === "function" && util.domainBind(domain, handler),
2279 | promise: promise,
2280 | receiver: receiver,
2281 | value: value
2282 | });
2283 | } else {
2284 | target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
2285 | }
2286 |
2287 | return promise;
2288 | };
2289 |
2290 | Promise.prototype._length = function () {
2291 | return this._bitField & 65535;
2292 | };
2293 |
2294 | Promise.prototype._isFateSealed = function () {
2295 | return (this._bitField & 117506048) !== 0;
2296 | };
2297 |
2298 | Promise.prototype._isFollowing = function () {
2299 | return (this._bitField & 67108864) === 67108864;
2300 | };
2301 |
2302 | Promise.prototype._setLength = function (len) {
2303 | this._bitField = this._bitField & -65536 | len & 65535;
2304 | };
2305 |
2306 | Promise.prototype._setFulfilled = function () {
2307 | this._bitField = this._bitField | 33554432;
2308 | this._fireEvent("promiseFulfilled", this);
2309 | };
2310 |
2311 | Promise.prototype._setRejected = function () {
2312 | this._bitField = this._bitField | 16777216;
2313 | this._fireEvent("promiseRejected", this);
2314 | };
2315 |
2316 | Promise.prototype._setFollowing = function () {
2317 | this._bitField = this._bitField | 67108864;
2318 | this._fireEvent("promiseResolved", this);
2319 | };
2320 |
2321 | Promise.prototype._setIsFinal = function () {
2322 | this._bitField = this._bitField | 4194304;
2323 | };
2324 |
2325 | Promise.prototype._isFinal = function () {
2326 | return (this._bitField & 4194304) > 0;
2327 | };
2328 |
2329 | Promise.prototype._unsetCancelled = function () {
2330 | this._bitField = this._bitField & ~65536;
2331 | };
2332 |
2333 | Promise.prototype._setCancelled = function () {
2334 | this._bitField = this._bitField | 65536;
2335 | this._fireEvent("promiseCancelled", this);
2336 | };
2337 |
2338 | Promise.prototype._setWillBeCancelled = function () {
2339 | this._bitField = this._bitField | 8388608;
2340 | };
2341 |
2342 | Promise.prototype._setAsyncGuaranteed = function () {
2343 | if (async.hasCustomScheduler()) return;
2344 | this._bitField = this._bitField | 134217728;
2345 | };
2346 |
2347 | Promise.prototype._receiverAt = function (index) {
2348 | var ret = index === 0 ? this._receiver0 : this[index * 4 - 4 + 3];
2349 | if (ret === UNDEFINED_BINDING) {
2350 | return undefined;
2351 | } else if (ret === undefined && this._isBound()) {
2352 | return this._boundValue();
2353 | }
2354 | return ret;
2355 | };
2356 |
2357 | Promise.prototype._promiseAt = function (index) {
2358 | return this[index * 4 - 4 + 2];
2359 | };
2360 |
2361 | Promise.prototype._fulfillmentHandlerAt = function (index) {
2362 | return this[index * 4 - 4 + 0];
2363 | };
2364 |
2365 | Promise.prototype._rejectionHandlerAt = function (index) {
2366 | return this[index * 4 - 4 + 1];
2367 | };
2368 |
2369 | Promise.prototype._boundValue = function () {};
2370 |
2371 | Promise.prototype._migrateCallback0 = function (follower) {
2372 | var bitField = follower._bitField;
2373 | var fulfill = follower._fulfillmentHandler0;
2374 | var reject = follower._rejectionHandler0;
2375 | var promise = follower._promise0;
2376 | var receiver = follower._receiverAt(0);
2377 | if (receiver === undefined) receiver = UNDEFINED_BINDING;
2378 | this._addCallbacks(fulfill, reject, promise, receiver, null);
2379 | };
2380 |
2381 | Promise.prototype._migrateCallbackAt = function (follower, index) {
2382 | var fulfill = follower._fulfillmentHandlerAt(index);
2383 | var reject = follower._rejectionHandlerAt(index);
2384 | var promise = follower._promiseAt(index);
2385 | var receiver = follower._receiverAt(index);
2386 | if (receiver === undefined) receiver = UNDEFINED_BINDING;
2387 | this._addCallbacks(fulfill, reject, promise, receiver, null);
2388 | };
2389 |
2390 | Promise.prototype._addCallbacks = function (fulfill, reject, promise, receiver, domain) {
2391 | var index = this._length();
2392 |
2393 | if (index >= 65535 - 4) {
2394 | index = 0;
2395 | this._setLength(0);
2396 | }
2397 |
2398 | if (index === 0) {
2399 | this._promise0 = promise;
2400 | this._receiver0 = receiver;
2401 | if (typeof fulfill === "function") {
2402 | this._fulfillmentHandler0 = domain === null ? fulfill : util.domainBind(domain, fulfill);
2403 | }
2404 | if (typeof reject === "function") {
2405 | this._rejectionHandler0 = domain === null ? reject : util.domainBind(domain, reject);
2406 | }
2407 | } else {
2408 | var base = index * 4 - 4;
2409 | this[base + 2] = promise;
2410 | this[base + 3] = receiver;
2411 | if (typeof fulfill === "function") {
2412 | this[base + 0] = domain === null ? fulfill : util.domainBind(domain, fulfill);
2413 | }
2414 | if (typeof reject === "function") {
2415 | this[base + 1] = domain === null ? reject : util.domainBind(domain, reject);
2416 | }
2417 | }
2418 | this._setLength(index + 1);
2419 | return index;
2420 | };
2421 |
2422 | Promise.prototype._proxy = function (proxyable, arg) {
2423 | this._addCallbacks(undefined, undefined, arg, proxyable, null);
2424 | };
2425 |
2426 | Promise.prototype._resolveCallback = function (value, shouldBind) {
2427 | if ((this._bitField & 117506048) !== 0) return;
2428 | if (value === this) return this._rejectCallback(makeSelfResolutionError(), false);
2429 | var maybePromise = tryConvertToPromise(value, this);
2430 | if (!(maybePromise instanceof Promise)) return this._fulfill(value);
2431 |
2432 | if (shouldBind) this._propagateFrom(maybePromise, 2);
2433 |
2434 | var promise = maybePromise._target();
2435 |
2436 | if (promise === this) {
2437 | this._reject(makeSelfResolutionError());
2438 | return;
2439 | }
2440 |
2441 | var bitField = promise._bitField;
2442 | if ((bitField & 50397184) === 0) {
2443 | var len = this._length();
2444 | if (len > 0) promise._migrateCallback0(this);
2445 | for (var i = 1; i < len; ++i) {
2446 | promise._migrateCallbackAt(this, i);
2447 | }
2448 | this._setFollowing();
2449 | this._setLength(0);
2450 | this._setFollowee(promise);
2451 | } else if ((bitField & 33554432) !== 0) {
2452 | this._fulfill(promise._value());
2453 | } else if ((bitField & 16777216) !== 0) {
2454 | this._reject(promise._reason());
2455 | } else {
2456 | var reason = new CancellationError("late cancellation observer");
2457 | promise._attachExtraTrace(reason);
2458 | this._reject(reason);
2459 | }
2460 | };
2461 |
2462 | Promise.prototype._rejectCallback = function (reason, synchronous, ignoreNonErrorWarnings) {
2463 | var trace = util.ensureErrorObject(reason);
2464 | var hasStack = trace === reason;
2465 | if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
2466 | var message = "a promise was rejected with a non-error: " + util.classString(reason);
2467 | this._warn(message, true);
2468 | }
2469 | this._attachExtraTrace(trace, synchronous ? hasStack : false);
2470 | this._reject(reason);
2471 | };
2472 |
2473 | Promise.prototype._resolveFromExecutor = function (executor) {
2474 | var promise = this;
2475 | this._captureStackTrace();
2476 | this._pushContext();
2477 | var synchronous = true;
2478 | var r = this._execute(executor, function (value) {
2479 | promise._resolveCallback(value);
2480 | }, function (reason) {
2481 | promise._rejectCallback(reason, synchronous);
2482 | });
2483 | synchronous = false;
2484 | this._popContext();
2485 |
2486 | if (r !== undefined) {
2487 | promise._rejectCallback(r, true);
2488 | }
2489 | };
2490 |
2491 | Promise.prototype._settlePromiseFromHandler = function (handler, receiver, value, promise) {
2492 | var bitField = promise._bitField;
2493 | if ((bitField & 65536) !== 0) return;
2494 | promise._pushContext();
2495 | var x;
2496 | if (receiver === APPLY) {
2497 | if (!value || typeof value.length !== "number") {
2498 | x = errorObj;
2499 | x.e = new TypeError("cannot .spread() a non-array: " + util.classString(value));
2500 | } else {
2501 | x = tryCatch(handler).apply(this._boundValue(), value);
2502 | }
2503 | } else {
2504 | x = tryCatch(handler).call(receiver, value);
2505 | }
2506 | var promiseCreated = promise._popContext();
2507 | bitField = promise._bitField;
2508 | if ((bitField & 65536) !== 0) return;
2509 |
2510 | if (x === NEXT_FILTER) {
2511 | promise._reject(value);
2512 | } else if (x === errorObj) {
2513 | promise._rejectCallback(x.e, false);
2514 | } else {
2515 | debug.checkForgottenReturns(x, promiseCreated, "", promise, this);
2516 | promise._resolveCallback(x);
2517 | }
2518 | };
2519 |
2520 | Promise.prototype._target = function () {
2521 | var ret = this;
2522 | while (ret._isFollowing()) {
2523 | ret = ret._followee();
2524 | }return ret;
2525 | };
2526 |
2527 | Promise.prototype._followee = function () {
2528 | return this._rejectionHandler0;
2529 | };
2530 |
2531 | Promise.prototype._setFollowee = function (promise) {
2532 | this._rejectionHandler0 = promise;
2533 | };
2534 |
2535 | Promise.prototype._settlePromise = function (promise, handler, receiver, value) {
2536 | var isPromise = promise instanceof Promise;
2537 | var bitField = this._bitField;
2538 | var asyncGuaranteed = (bitField & 134217728) !== 0;
2539 | if ((bitField & 65536) !== 0) {
2540 | if (isPromise) promise._invokeInternalOnCancel();
2541 |
2542 | if (receiver instanceof PassThroughHandlerContext && receiver.isFinallyHandler()) {
2543 | receiver.cancelPromise = promise;
2544 | if (tryCatch(handler).call(receiver, value) === errorObj) {
2545 | promise._reject(errorObj.e);
2546 | }
2547 | } else if (handler === reflectHandler) {
2548 | promise._fulfill(reflectHandler.call(receiver));
2549 | } else if (receiver instanceof Proxyable) {
2550 | receiver._promiseCancelled(promise);
2551 | } else if (isPromise || promise instanceof PromiseArray) {
2552 | promise._cancel();
2553 | } else {
2554 | receiver.cancel();
2555 | }
2556 | } else if (typeof handler === "function") {
2557 | if (!isPromise) {
2558 | handler.call(receiver, value, promise);
2559 | } else {
2560 | if (asyncGuaranteed) promise._setAsyncGuaranteed();
2561 | this._settlePromiseFromHandler(handler, receiver, value, promise);
2562 | }
2563 | } else if (receiver instanceof Proxyable) {
2564 | if (!receiver._isResolved()) {
2565 | if ((bitField & 33554432) !== 0) {
2566 | receiver._promiseFulfilled(value, promise);
2567 | } else {
2568 | receiver._promiseRejected(value, promise);
2569 | }
2570 | }
2571 | } else if (isPromise) {
2572 | if (asyncGuaranteed) promise._setAsyncGuaranteed();
2573 | if ((bitField & 33554432) !== 0) {
2574 | promise._fulfill(value);
2575 | } else {
2576 | promise._reject(value);
2577 | }
2578 | }
2579 | };
2580 |
2581 | Promise.prototype._settlePromiseLateCancellationObserver = function (ctx) {
2582 | var handler = ctx.handler;
2583 | var promise = ctx.promise;
2584 | var receiver = ctx.receiver;
2585 | var value = ctx.value;
2586 | if (typeof handler === "function") {
2587 | if (!(promise instanceof Promise)) {
2588 | handler.call(receiver, value, promise);
2589 | } else {
2590 | this._settlePromiseFromHandler(handler, receiver, value, promise);
2591 | }
2592 | } else if (promise instanceof Promise) {
2593 | promise._reject(value);
2594 | }
2595 | };
2596 |
2597 | Promise.prototype._settlePromiseCtx = function (ctx) {
2598 | this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
2599 | };
2600 |
2601 | Promise.prototype._settlePromise0 = function (handler, value, bitField) {
2602 | var promise = this._promise0;
2603 | var receiver = this._receiverAt(0);
2604 | this._promise0 = undefined;
2605 | this._receiver0 = undefined;
2606 | this._settlePromise(promise, handler, receiver, value);
2607 | };
2608 |
2609 | Promise.prototype._clearCallbackDataAtIndex = function (index) {
2610 | var base = index * 4 - 4;
2611 | this[base + 2] = this[base + 3] = this[base + 0] = this[base + 1] = undefined;
2612 | };
2613 |
2614 | Promise.prototype._fulfill = function (value) {
2615 | var bitField = this._bitField;
2616 | if ((bitField & 117506048) >>> 16) return;
2617 | if (value === this) {
2618 | var err = makeSelfResolutionError();
2619 | this._attachExtraTrace(err);
2620 | return this._reject(err);
2621 | }
2622 | this._setFulfilled();
2623 | this._rejectionHandler0 = value;
2624 |
2625 | if ((bitField & 65535) > 0) {
2626 | if ((bitField & 134217728) !== 0) {
2627 | this._settlePromises();
2628 | } else {
2629 | async.settlePromises(this);
2630 | }
2631 | }
2632 | };
2633 |
2634 | Promise.prototype._reject = function (reason) {
2635 | var bitField = this._bitField;
2636 | if ((bitField & 117506048) >>> 16) return;
2637 | this._setRejected();
2638 | this._fulfillmentHandler0 = reason;
2639 |
2640 | if (this._isFinal()) {
2641 | return async.fatalError(reason, util.isNode);
2642 | }
2643 |
2644 | if ((bitField & 65535) > 0) {
2645 | async.settlePromises(this);
2646 | } else {
2647 | this._ensurePossibleRejectionHandled();
2648 | }
2649 | };
2650 |
2651 | Promise.prototype._fulfillPromises = function (len, value) {
2652 | for (var i = 1; i < len; i++) {
2653 | var handler = this._fulfillmentHandlerAt(i);
2654 | var promise = this._promiseAt(i);
2655 | var receiver = this._receiverAt(i);
2656 | this._clearCallbackDataAtIndex(i);
2657 | this._settlePromise(promise, handler, receiver, value);
2658 | }
2659 | };
2660 |
2661 | Promise.prototype._rejectPromises = function (len, reason) {
2662 | for (var i = 1; i < len; i++) {
2663 | var handler = this._rejectionHandlerAt(i);
2664 | var promise = this._promiseAt(i);
2665 | var receiver = this._receiverAt(i);
2666 | this._clearCallbackDataAtIndex(i);
2667 | this._settlePromise(promise, handler, receiver, reason);
2668 | }
2669 | };
2670 |
2671 | Promise.prototype._settlePromises = function () {
2672 | var bitField = this._bitField;
2673 | var len = bitField & 65535;
2674 |
2675 | if (len > 0) {
2676 | if ((bitField & 16842752) !== 0) {
2677 | var reason = this._fulfillmentHandler0;
2678 | this._settlePromise0(this._rejectionHandler0, reason, bitField);
2679 | this._rejectPromises(len, reason);
2680 | } else {
2681 | var value = this._rejectionHandler0;
2682 | this._settlePromise0(this._fulfillmentHandler0, value, bitField);
2683 | this._fulfillPromises(len, value);
2684 | }
2685 | this._setLength(0);
2686 | }
2687 | this._clearCancellationData();
2688 | };
2689 |
2690 | Promise.prototype._settledValue = function () {
2691 | var bitField = this._bitField;
2692 | if ((bitField & 33554432) !== 0) {
2693 | return this._rejectionHandler0;
2694 | } else if ((bitField & 16777216) !== 0) {
2695 | return this._fulfillmentHandler0;
2696 | }
2697 | };
2698 |
2699 | function deferResolve(v) {
2700 | this.promise._resolveCallback(v);
2701 | }
2702 | function deferReject(v) {
2703 | this.promise._rejectCallback(v, false);
2704 | }
2705 |
2706 | Promise.defer = Promise.pending = function () {
2707 | debug.deprecated("Promise.defer", "new Promise");
2708 | var promise = new Promise(INTERNAL);
2709 | return {
2710 | promise: promise,
2711 | resolve: deferResolve,
2712 | reject: deferReject
2713 | };
2714 | };
2715 |
2716 | util.notEnumerableProp(Promise, "_makeSelfResolutionError", makeSelfResolutionError);
2717 |
2718 | _dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug);
2719 | _dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
2720 | _dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug);
2721 | _dereq_("./direct_resolve")(Promise);
2722 | _dereq_("./synchronous_inspection")(Promise);
2723 | _dereq_("./join")(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);
2724 | Promise.Promise = Promise;
2725 | Promise.version = "3.4.6";
2726 |
2727 | util.toFastProperties(Promise);
2728 | util.toFastProperties(Promise.prototype);
2729 | function fillTypes(value) {
2730 | var p = new Promise(INTERNAL);
2731 | p._fulfillmentHandler0 = value;
2732 | p._rejectionHandler0 = value;
2733 | p._promise0 = value;
2734 | p._receiver0 = value;
2735 | }
2736 | // Complete slack tracking, opt out of field-type tracking and
2737 | // stabilize map
2738 | fillTypes({ a: 1 });
2739 | fillTypes({ b: 2 });
2740 | fillTypes({ c: 3 });
2741 | fillTypes(1);
2742 | fillTypes(function () {});
2743 | fillTypes(undefined);
2744 | fillTypes(false);
2745 | fillTypes(new Promise(INTERNAL));
2746 | debug.setBounds(Async.firstLineError, util.lastLineError);
2747 | return Promise;
2748 | };
2749 | }, { "./async": 1, "./bind": 2, "./cancel": 4, "./catch_filter": 5, "./context": 6, "./debuggability": 7, "./direct_resolve": 8, "./errors": 9, "./es5": 10, "./finally": 11, "./join": 12, "./method": 13, "./nodeback": 14, "./promise_array": 16, "./synchronous_inspection": 19, "./thenables": 20, "./util": 21 }], 16: [function (_dereq_, module, exports) {
2750 | "use strict";
2751 |
2752 | module.exports = function (Promise, INTERNAL, tryConvertToPromise, apiRejection, Proxyable) {
2753 | var util = _dereq_("./util");
2754 | var isArray = util.isArray;
2755 |
2756 | function toResolutionValue(val) {
2757 | switch (val) {
2758 | case -2:
2759 | return [];
2760 | case -3:
2761 | return {};
2762 | }
2763 | }
2764 |
2765 | function PromiseArray(values) {
2766 | var promise = this._promise = new Promise(INTERNAL);
2767 | if (values instanceof Promise) {
2768 | promise._propagateFrom(values, 3);
2769 | }
2770 | promise._setOnCancel(this);
2771 | this._values = values;
2772 | this._length = 0;
2773 | this._totalResolved = 0;
2774 | this._init(undefined, -2);
2775 | }
2776 | util.inherits(PromiseArray, Proxyable);
2777 |
2778 | PromiseArray.prototype.length = function () {
2779 | return this._length;
2780 | };
2781 |
2782 | PromiseArray.prototype.promise = function () {
2783 | return this._promise;
2784 | };
2785 |
2786 | PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
2787 | var values = tryConvertToPromise(this._values, this._promise);
2788 | if (values instanceof Promise) {
2789 | values = values._target();
2790 | var bitField = values._bitField;
2791 | ;
2792 | this._values = values;
2793 |
2794 | if ((bitField & 50397184) === 0) {
2795 | this._promise._setAsyncGuaranteed();
2796 | return values._then(init, this._reject, undefined, this, resolveValueIfEmpty);
2797 | } else if ((bitField & 33554432) !== 0) {
2798 | values = values._value();
2799 | } else if ((bitField & 16777216) !== 0) {
2800 | return this._reject(values._reason());
2801 | } else {
2802 | return this._cancel();
2803 | }
2804 | }
2805 | values = util.asArray(values);
2806 | if (values === null) {
2807 | var err = apiRejection("expecting an array or an iterable object but got " + util.classString(values)).reason();
2808 | this._promise._rejectCallback(err, false);
2809 | return;
2810 | }
2811 |
2812 | if (values.length === 0) {
2813 | if (resolveValueIfEmpty === -5) {
2814 | this._resolveEmptyArray();
2815 | } else {
2816 | this._resolve(toResolutionValue(resolveValueIfEmpty));
2817 | }
2818 | return;
2819 | }
2820 | this._iterate(values);
2821 | };
2822 |
2823 | PromiseArray.prototype._iterate = function (values) {
2824 | var len = this.getActualLength(values.length);
2825 | this._length = len;
2826 | this._values = this.shouldCopyValues() ? new Array(len) : this._values;
2827 | var result = this._promise;
2828 | var isResolved = false;
2829 | var bitField = null;
2830 | for (var i = 0; i < len; ++i) {
2831 | var maybePromise = tryConvertToPromise(values[i], result);
2832 |
2833 | if (maybePromise instanceof Promise) {
2834 | maybePromise = maybePromise._target();
2835 | bitField = maybePromise._bitField;
2836 | } else {
2837 | bitField = null;
2838 | }
2839 |
2840 | if (isResolved) {
2841 | if (bitField !== null) {
2842 | maybePromise.suppressUnhandledRejections();
2843 | }
2844 | } else if (bitField !== null) {
2845 | if ((bitField & 50397184) === 0) {
2846 | maybePromise._proxy(this, i);
2847 | this._values[i] = maybePromise;
2848 | } else if ((bitField & 33554432) !== 0) {
2849 | isResolved = this._promiseFulfilled(maybePromise._value(), i);
2850 | } else if ((bitField & 16777216) !== 0) {
2851 | isResolved = this._promiseRejected(maybePromise._reason(), i);
2852 | } else {
2853 | isResolved = this._promiseCancelled(i);
2854 | }
2855 | } else {
2856 | isResolved = this._promiseFulfilled(maybePromise, i);
2857 | }
2858 | }
2859 | if (!isResolved) result._setAsyncGuaranteed();
2860 | };
2861 |
2862 | PromiseArray.prototype._isResolved = function () {
2863 | return this._values === null;
2864 | };
2865 |
2866 | PromiseArray.prototype._resolve = function (value) {
2867 | this._values = null;
2868 | this._promise._fulfill(value);
2869 | };
2870 |
2871 | PromiseArray.prototype._cancel = function () {
2872 | if (this._isResolved() || !this._promise._isCancellable()) return;
2873 | this._values = null;
2874 | this._promise._cancel();
2875 | };
2876 |
2877 | PromiseArray.prototype._reject = function (reason) {
2878 | this._values = null;
2879 | this._promise._rejectCallback(reason, false);
2880 | };
2881 |
2882 | PromiseArray.prototype._promiseFulfilled = function (value, index) {
2883 | this._values[index] = value;
2884 | var totalResolved = ++this._totalResolved;
2885 | if (totalResolved >= this._length) {
2886 | this._resolve(this._values);
2887 | return true;
2888 | }
2889 | return false;
2890 | };
2891 |
2892 | PromiseArray.prototype._promiseCancelled = function () {
2893 | this._cancel();
2894 | return true;
2895 | };
2896 |
2897 | PromiseArray.prototype._promiseRejected = function (reason) {
2898 | this._totalResolved++;
2899 | this._reject(reason);
2900 | return true;
2901 | };
2902 |
2903 | PromiseArray.prototype._resultCancelled = function () {
2904 | if (this._isResolved()) return;
2905 | var values = this._values;
2906 | this._cancel();
2907 | if (values instanceof Promise) {
2908 | values.cancel();
2909 | } else {
2910 | for (var i = 0; i < values.length; ++i) {
2911 | if (values[i] instanceof Promise) {
2912 | values[i].cancel();
2913 | }
2914 | }
2915 | }
2916 | };
2917 |
2918 | PromiseArray.prototype.shouldCopyValues = function () {
2919 | return true;
2920 | };
2921 |
2922 | PromiseArray.prototype.getActualLength = function (len) {
2923 | return len;
2924 | };
2925 |
2926 | return PromiseArray;
2927 | };
2928 | }, { "./util": 21 }], 17: [function (_dereq_, module, exports) {
2929 | "use strict";
2930 |
2931 | function arrayMove(src, srcIndex, dst, dstIndex, len) {
2932 | for (var j = 0; j < len; ++j) {
2933 | dst[j + dstIndex] = src[j + srcIndex];
2934 | src[j + srcIndex] = void 0;
2935 | }
2936 | }
2937 |
2938 | function Queue(capacity) {
2939 | this._capacity = capacity;
2940 | this._length = 0;
2941 | this._front = 0;
2942 | }
2943 |
2944 | Queue.prototype._willBeOverCapacity = function (size) {
2945 | return this._capacity < size;
2946 | };
2947 |
2948 | Queue.prototype._pushOne = function (arg) {
2949 | var length = this.length();
2950 | this._checkCapacity(length + 1);
2951 | var i = this._front + length & this._capacity - 1;
2952 | this[i] = arg;
2953 | this._length = length + 1;
2954 | };
2955 |
2956 | Queue.prototype._unshiftOne = function (value) {
2957 | var capacity = this._capacity;
2958 | this._checkCapacity(this.length() + 1);
2959 | var front = this._front;
2960 | var i = (front - 1 & capacity - 1 ^ capacity) - capacity;
2961 | this[i] = value;
2962 | this._front = i;
2963 | this._length = this.length() + 1;
2964 | };
2965 |
2966 | Queue.prototype.unshift = function (fn, receiver, arg) {
2967 | this._unshiftOne(arg);
2968 | this._unshiftOne(receiver);
2969 | this._unshiftOne(fn);
2970 | };
2971 |
2972 | Queue.prototype.push = function (fn, receiver, arg) {
2973 | var length = this.length() + 3;
2974 | if (this._willBeOverCapacity(length)) {
2975 | this._pushOne(fn);
2976 | this._pushOne(receiver);
2977 | this._pushOne(arg);
2978 | return;
2979 | }
2980 | var j = this._front + length - 3;
2981 | this._checkCapacity(length);
2982 | var wrapMask = this._capacity - 1;
2983 | this[j + 0 & wrapMask] = fn;
2984 | this[j + 1 & wrapMask] = receiver;
2985 | this[j + 2 & wrapMask] = arg;
2986 | this._length = length;
2987 | };
2988 |
2989 | Queue.prototype.shift = function () {
2990 | var front = this._front,
2991 | ret = this[front];
2992 |
2993 | this[front] = undefined;
2994 | this._front = front + 1 & this._capacity - 1;
2995 | this._length--;
2996 | return ret;
2997 | };
2998 |
2999 | Queue.prototype.length = function () {
3000 | return this._length;
3001 | };
3002 |
3003 | Queue.prototype._checkCapacity = function (size) {
3004 | if (this._capacity < size) {
3005 | this._resizeTo(this._capacity << 1);
3006 | }
3007 | };
3008 |
3009 | Queue.prototype._resizeTo = function (capacity) {
3010 | var oldCapacity = this._capacity;
3011 | this._capacity = capacity;
3012 | var front = this._front;
3013 | var length = this._length;
3014 | var moveItemsCount = front + length & oldCapacity - 1;
3015 | arrayMove(this, 0, this, oldCapacity, moveItemsCount);
3016 | };
3017 |
3018 | module.exports = Queue;
3019 | }, {}], 18: [function (_dereq_, module, exports) {
3020 | "use strict";
3021 |
3022 | var util = _dereq_("./util");
3023 | var schedule;
3024 | var noAsyncScheduler = function noAsyncScheduler() {
3025 | throw new Error("No async scheduler available\n\n See http://goo.gl/MqrFmX\n");
3026 | };
3027 | var NativePromise = util.getNativePromise();
3028 | if (util.isNode && typeof MutationObserver === "undefined") {
3029 | var GlobalSetImmediate = global.setImmediate;
3030 | var ProcessNextTick = process.nextTick;
3031 | schedule = util.isRecentNode ? function (fn) {
3032 | GlobalSetImmediate.call(global, fn);
3033 | } : function (fn) {
3034 | ProcessNextTick.call(process, fn);
3035 | };
3036 | } else if (typeof NativePromise === "function" && typeof NativePromise.resolve === "function") {
3037 | var nativePromise = NativePromise.resolve();
3038 | schedule = function schedule(fn) {
3039 | nativePromise.then(fn);
3040 | };
3041 | } else if (typeof MutationObserver !== "undefined" && !(typeof window !== "undefined" && window.navigator && (window.navigator.standalone || window.cordova))) {
3042 | schedule = function () {
3043 | var div = document.createElement("div");
3044 | var opts = { attributes: true };
3045 | var toggleScheduled = false;
3046 | var div2 = document.createElement("div");
3047 | var o2 = new MutationObserver(function () {
3048 | div.classList.toggle("foo");
3049 | toggleScheduled = false;
3050 | });
3051 | o2.observe(div2, opts);
3052 |
3053 | var scheduleToggle = function scheduleToggle() {
3054 | if (toggleScheduled) return;
3055 | toggleScheduled = true;
3056 | div2.classList.toggle("foo");
3057 | };
3058 |
3059 | return function schedule(fn) {
3060 | var o = new MutationObserver(function () {
3061 | o.disconnect();
3062 | fn();
3063 | });
3064 | o.observe(div, opts);
3065 | scheduleToggle();
3066 | };
3067 | }();
3068 | } else if (typeof setImmediate !== "undefined") {
3069 | schedule = function schedule(fn) {
3070 | setImmediate(fn);
3071 | };
3072 | } else if (typeof setTimeout !== "undefined") {
3073 | schedule = function schedule(fn) {
3074 | setTimeout(fn, 0);
3075 | };
3076 | } else {
3077 | schedule = noAsyncScheduler;
3078 | }
3079 | module.exports = schedule;
3080 | }, { "./util": 21 }], 19: [function (_dereq_, module, exports) {
3081 | "use strict";
3082 |
3083 | module.exports = function (Promise) {
3084 | function PromiseInspection(promise) {
3085 | if (promise !== undefined) {
3086 | promise = promise._target();
3087 | this._bitField = promise._bitField;
3088 | this._settledValueField = promise._isFateSealed() ? promise._settledValue() : undefined;
3089 | } else {
3090 | this._bitField = 0;
3091 | this._settledValueField = undefined;
3092 | }
3093 | }
3094 |
3095 | PromiseInspection.prototype._settledValue = function () {
3096 | return this._settledValueField;
3097 | };
3098 |
3099 | var value = PromiseInspection.prototype.value = function () {
3100 | if (!this.isFulfilled()) {
3101 | throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\n\n See http://goo.gl/MqrFmX\n");
3102 | }
3103 | return this._settledValue();
3104 | };
3105 |
3106 | var reason = PromiseInspection.prototype.error = PromiseInspection.prototype.reason = function () {
3107 | if (!this.isRejected()) {
3108 | throw new TypeError("cannot get rejection reason of a non-rejected promise\n\n See http://goo.gl/MqrFmX\n");
3109 | }
3110 | return this._settledValue();
3111 | };
3112 |
3113 | var isFulfilled = PromiseInspection.prototype.isFulfilled = function () {
3114 | return (this._bitField & 33554432) !== 0;
3115 | };
3116 |
3117 | var isRejected = PromiseInspection.prototype.isRejected = function () {
3118 | return (this._bitField & 16777216) !== 0;
3119 | };
3120 |
3121 | var isPending = PromiseInspection.prototype.isPending = function () {
3122 | return (this._bitField & 50397184) === 0;
3123 | };
3124 |
3125 | var isResolved = PromiseInspection.prototype.isResolved = function () {
3126 | return (this._bitField & 50331648) !== 0;
3127 | };
3128 |
3129 | PromiseInspection.prototype.isCancelled = function () {
3130 | return (this._bitField & 8454144) !== 0;
3131 | };
3132 |
3133 | Promise.prototype.__isCancelled = function () {
3134 | return (this._bitField & 65536) === 65536;
3135 | };
3136 |
3137 | Promise.prototype._isCancelled = function () {
3138 | return this._target().__isCancelled();
3139 | };
3140 |
3141 | Promise.prototype.isCancelled = function () {
3142 | return (this._target()._bitField & 8454144) !== 0;
3143 | };
3144 |
3145 | Promise.prototype.isPending = function () {
3146 | return isPending.call(this._target());
3147 | };
3148 |
3149 | Promise.prototype.isRejected = function () {
3150 | return isRejected.call(this._target());
3151 | };
3152 |
3153 | Promise.prototype.isFulfilled = function () {
3154 | return isFulfilled.call(this._target());
3155 | };
3156 |
3157 | Promise.prototype.isResolved = function () {
3158 | return isResolved.call(this._target());
3159 | };
3160 |
3161 | Promise.prototype.value = function () {
3162 | return value.call(this._target());
3163 | };
3164 |
3165 | Promise.prototype.reason = function () {
3166 | var target = this._target();
3167 | target._unsetRejectionIsUnhandled();
3168 | return reason.call(target);
3169 | };
3170 |
3171 | Promise.prototype._value = function () {
3172 | return this._settledValue();
3173 | };
3174 |
3175 | Promise.prototype._reason = function () {
3176 | this._unsetRejectionIsUnhandled();
3177 | return this._settledValue();
3178 | };
3179 |
3180 | Promise.PromiseInspection = PromiseInspection;
3181 | };
3182 | }, {}], 20: [function (_dereq_, module, exports) {
3183 | "use strict";
3184 |
3185 | module.exports = function (Promise, INTERNAL) {
3186 | var util = _dereq_("./util");
3187 | var errorObj = util.errorObj;
3188 | var isObject = util.isObject;
3189 |
3190 | function tryConvertToPromise(obj, context) {
3191 | if (isObject(obj)) {
3192 | if (obj instanceof Promise) return obj;
3193 | var then = getThen(obj);
3194 | if (then === errorObj) {
3195 | if (context) context._pushContext();
3196 | var ret = Promise.reject(then.e);
3197 | if (context) context._popContext();
3198 | return ret;
3199 | } else if (typeof then === "function") {
3200 | if (isAnyBluebirdPromise(obj)) {
3201 | var ret = new Promise(INTERNAL);
3202 | obj._then(ret._fulfill, ret._reject, undefined, ret, null);
3203 | return ret;
3204 | }
3205 | return doThenable(obj, then, context);
3206 | }
3207 | }
3208 | return obj;
3209 | }
3210 |
3211 | function doGetThen(obj) {
3212 | return obj.then;
3213 | }
3214 |
3215 | function getThen(obj) {
3216 | try {
3217 | return doGetThen(obj);
3218 | } catch (e) {
3219 | errorObj.e = e;
3220 | return errorObj;
3221 | }
3222 | }
3223 |
3224 | var hasProp = {}.hasOwnProperty;
3225 | function isAnyBluebirdPromise(obj) {
3226 | try {
3227 | return hasProp.call(obj, "_promise0");
3228 | } catch (e) {
3229 | return false;
3230 | }
3231 | }
3232 |
3233 | function doThenable(x, then, context) {
3234 | var promise = new Promise(INTERNAL);
3235 | var ret = promise;
3236 | if (context) context._pushContext();
3237 | promise._captureStackTrace();
3238 | if (context) context._popContext();
3239 | var synchronous = true;
3240 | var result = util.tryCatch(then).call(x, resolve, reject);
3241 | synchronous = false;
3242 |
3243 | if (promise && result === errorObj) {
3244 | promise._rejectCallback(result.e, true, true);
3245 | promise = null;
3246 | }
3247 |
3248 | function resolve(value) {
3249 | if (!promise) return;
3250 | promise._resolveCallback(value);
3251 | promise = null;
3252 | }
3253 |
3254 | function reject(reason) {
3255 | if (!promise) return;
3256 | promise._rejectCallback(reason, synchronous, true);
3257 | promise = null;
3258 | }
3259 | return ret;
3260 | }
3261 |
3262 | return tryConvertToPromise;
3263 | };
3264 | }, { "./util": 21 }], 21: [function (_dereq_, module, exports) {
3265 | "use strict";
3266 |
3267 | var es5 = _dereq_("./es5");
3268 | var canEvaluate = typeof navigator == "undefined";
3269 |
3270 | var errorObj = { e: {} };
3271 | var tryCatchTarget;
3272 | var globalObject = typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : this !== undefined ? this : null;
3273 |
3274 | function tryCatcher() {
3275 | try {
3276 | var target = tryCatchTarget;
3277 | tryCatchTarget = null;
3278 | return target.apply(this, arguments);
3279 | } catch (e) {
3280 | errorObj.e = e;
3281 | return errorObj;
3282 | }
3283 | }
3284 | function tryCatch(fn) {
3285 | tryCatchTarget = fn;
3286 | return tryCatcher;
3287 | }
3288 |
3289 | var inherits = function inherits(Child, Parent) {
3290 | var hasProp = {}.hasOwnProperty;
3291 |
3292 | function T() {
3293 | this.constructor = Child;
3294 | this.constructor$ = Parent;
3295 | for (var propertyName in Parent.prototype) {
3296 | if (hasProp.call(Parent.prototype, propertyName) && propertyName.charAt(propertyName.length - 1) !== "$") {
3297 | this[propertyName + "$"] = Parent.prototype[propertyName];
3298 | }
3299 | }
3300 | }
3301 | T.prototype = Parent.prototype;
3302 | Child.prototype = new T();
3303 | return Child.prototype;
3304 | };
3305 |
3306 | function isPrimitive(val) {
3307 | return val == null || val === true || val === false || typeof val === "string" || typeof val === "number";
3308 | }
3309 |
3310 | function isObject(value) {
3311 | return typeof value === "function" || (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object" && value !== null;
3312 | }
3313 |
3314 | function maybeWrapAsError(maybeError) {
3315 | if (!isPrimitive(maybeError)) return maybeError;
3316 |
3317 | return new Error(safeToString(maybeError));
3318 | }
3319 |
3320 | function withAppended(target, appendee) {
3321 | var len = target.length;
3322 | var ret = new Array(len + 1);
3323 | var i;
3324 | for (i = 0; i < len; ++i) {
3325 | ret[i] = target[i];
3326 | }
3327 | ret[i] = appendee;
3328 | return ret;
3329 | }
3330 |
3331 | function getDataPropertyOrDefault(obj, key, defaultValue) {
3332 | if (es5.isES5) {
3333 | var desc = Object.getOwnPropertyDescriptor(obj, key);
3334 |
3335 | if (desc != null) {
3336 | return desc.get == null && desc.set == null ? desc.value : defaultValue;
3337 | }
3338 | } else {
3339 | return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
3340 | }
3341 | }
3342 |
3343 | function notEnumerableProp(obj, name, value) {
3344 | if (isPrimitive(obj)) return obj;
3345 | var descriptor = {
3346 | value: value,
3347 | configurable: true,
3348 | enumerable: false,
3349 | writable: true
3350 | };
3351 | es5.defineProperty(obj, name, descriptor);
3352 | return obj;
3353 | }
3354 |
3355 | function thrower(r) {
3356 | throw r;
3357 | }
3358 |
3359 | var inheritedDataKeys = function () {
3360 | var excludedPrototypes = [Array.prototype, Object.prototype, Function.prototype];
3361 |
3362 | var isExcludedProto = function isExcludedProto(val) {
3363 | for (var i = 0; i < excludedPrototypes.length; ++i) {
3364 | if (excludedPrototypes[i] === val) {
3365 | return true;
3366 | }
3367 | }
3368 | return false;
3369 | };
3370 |
3371 | if (es5.isES5) {
3372 | var getKeys = Object.getOwnPropertyNames;
3373 | return function (obj) {
3374 | var ret = [];
3375 | var visitedKeys = Object.create(null);
3376 | while (obj != null && !isExcludedProto(obj)) {
3377 | var keys;
3378 | try {
3379 | keys = getKeys(obj);
3380 | } catch (e) {
3381 | return ret;
3382 | }
3383 | for (var i = 0; i < keys.length; ++i) {
3384 | var key = keys[i];
3385 | if (visitedKeys[key]) continue;
3386 | visitedKeys[key] = true;
3387 | var desc = Object.getOwnPropertyDescriptor(obj, key);
3388 | if (desc != null && desc.get == null && desc.set == null) {
3389 | ret.push(key);
3390 | }
3391 | }
3392 | obj = es5.getPrototypeOf(obj);
3393 | }
3394 | return ret;
3395 | };
3396 | } else {
3397 | var hasProp = {}.hasOwnProperty;
3398 | return function (obj) {
3399 | if (isExcludedProto(obj)) return [];
3400 | var ret = [];
3401 |
3402 | /*jshint forin:false */
3403 | enumeration: for (var key in obj) {
3404 | if (hasProp.call(obj, key)) {
3405 | ret.push(key);
3406 | } else {
3407 | for (var i = 0; i < excludedPrototypes.length; ++i) {
3408 | if (hasProp.call(excludedPrototypes[i], key)) {
3409 | continue enumeration;
3410 | }
3411 | }
3412 | ret.push(key);
3413 | }
3414 | }
3415 | return ret;
3416 | };
3417 | }
3418 | }();
3419 |
3420 | var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
3421 | function isClass(fn) {
3422 | try {
3423 | if (typeof fn === "function") {
3424 | var keys = es5.names(fn.prototype);
3425 |
3426 | var hasMethods = es5.isES5 && keys.length > 1;
3427 | var hasMethodsOtherThanConstructor = keys.length > 0 && !(keys.length === 1 && keys[0] === "constructor");
3428 | var hasThisAssignmentAndStaticMethods = thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
3429 |
3430 | if (hasMethods || hasMethodsOtherThanConstructor || hasThisAssignmentAndStaticMethods) {
3431 | return true;
3432 | }
3433 | }
3434 | return false;
3435 | } catch (e) {
3436 | return false;
3437 | }
3438 | }
3439 |
3440 | function toFastProperties(obj) {
3441 | /*jshint -W027,-W055,-W031*/
3442 | function FakeConstructor() {}
3443 | FakeConstructor.prototype = obj;
3444 | var l = 8;
3445 | while (l--) {
3446 | new FakeConstructor();
3447 | }return obj;
3448 | eval(obj);
3449 | }
3450 |
3451 | var rident = /^[a-z$_][a-z$_0-9]*$/i;
3452 | function isIdentifier(str) {
3453 | return rident.test(str);
3454 | }
3455 |
3456 | function filledRange(count, prefix, suffix) {
3457 | var ret = new Array(count);
3458 | for (var i = 0; i < count; ++i) {
3459 | ret[i] = prefix + i + suffix;
3460 | }
3461 | return ret;
3462 | }
3463 |
3464 | function safeToString(obj) {
3465 | try {
3466 | return obj + "";
3467 | } catch (e) {
3468 | return "[no string representation]";
3469 | }
3470 | }
3471 |
3472 | function isError(obj) {
3473 | return obj !== null && (typeof obj === "undefined" ? "undefined" : _typeof(obj)) === "object" && typeof obj.message === "string" && typeof obj.name === "string";
3474 | }
3475 |
3476 | function markAsOriginatingFromRejection(e) {
3477 | try {
3478 | notEnumerableProp(e, "isOperational", true);
3479 | } catch (ignore) {}
3480 | }
3481 |
3482 | function originatesFromRejection(e) {
3483 | if (e == null) return false;
3484 | return e instanceof Error["__BluebirdErrorTypes__"].OperationalError || e["isOperational"] === true;
3485 | }
3486 |
3487 | function canAttachTrace(obj) {
3488 | return isError(obj) && es5.propertyIsWritable(obj, "stack");
3489 | }
3490 |
3491 | var ensureErrorObject = function () {
3492 | if (!("stack" in new Error())) {
3493 | return function (value) {
3494 | if (canAttachTrace(value)) return value;
3495 | try {
3496 | throw new Error(safeToString(value));
3497 | } catch (err) {
3498 | return err;
3499 | }
3500 | };
3501 | } else {
3502 | return function (value) {
3503 | if (canAttachTrace(value)) return value;
3504 | return new Error(safeToString(value));
3505 | };
3506 | }
3507 | }();
3508 |
3509 | function classString(obj) {
3510 | return {}.toString.call(obj);
3511 | }
3512 |
3513 | function copyDescriptors(from, to, filter) {
3514 | var keys = es5.names(from);
3515 | for (var i = 0; i < keys.length; ++i) {
3516 | var key = keys[i];
3517 | if (filter(key)) {
3518 | try {
3519 | es5.defineProperty(to, key, es5.getDescriptor(from, key));
3520 | } catch (ignore) {}
3521 | }
3522 | }
3523 | }
3524 |
3525 | var asArray = function asArray(v) {
3526 | if (es5.isArray(v)) {
3527 | return v;
3528 | }
3529 | return null;
3530 | };
3531 |
3532 | if (typeof Symbol !== "undefined" && Symbol.iterator) {
3533 | var ArrayFrom = typeof Array.from === "function" ? function (v) {
3534 | return Array.from(v);
3535 | } : function (v) {
3536 | var ret = [];
3537 | var it = v[Symbol.iterator]();
3538 | var itResult;
3539 | while (!(itResult = it.next()).done) {
3540 | ret.push(itResult.value);
3541 | }
3542 | return ret;
3543 | };
3544 |
3545 | asArray = function asArray(v) {
3546 | if (es5.isArray(v)) {
3547 | return v;
3548 | } else if (v != null && typeof v[Symbol.iterator] === "function") {
3549 | return ArrayFrom(v);
3550 | }
3551 | return null;
3552 | };
3553 | }
3554 |
3555 | var isNode = typeof process !== "undefined" && classString(process).toLowerCase() === "[object process]";
3556 |
3557 | function env(key, def) {
3558 | return isNode ? process.env[key] : def;
3559 | }
3560 |
3561 | function getNativePromise() {
3562 | if (typeof Promise === "function") {
3563 | try {
3564 | var promise = new Promise(function () {});
3565 | if ({}.toString.call(promise) === "[object Promise]") {
3566 | return Promise;
3567 | }
3568 | } catch (e) {}
3569 | }
3570 | }
3571 |
3572 | function domainBind(self, cb) {
3573 | return self.bind(cb);
3574 | }
3575 |
3576 | var ret = {
3577 | isClass: isClass,
3578 | isIdentifier: isIdentifier,
3579 | inheritedDataKeys: inheritedDataKeys,
3580 | getDataPropertyOrDefault: getDataPropertyOrDefault,
3581 | thrower: thrower,
3582 | isArray: es5.isArray,
3583 | asArray: asArray,
3584 | notEnumerableProp: notEnumerableProp,
3585 | isPrimitive: isPrimitive,
3586 | isObject: isObject,
3587 | isError: isError,
3588 | canEvaluate: canEvaluate,
3589 | errorObj: errorObj,
3590 | tryCatch: tryCatch,
3591 | inherits: inherits,
3592 | withAppended: withAppended,
3593 | maybeWrapAsError: maybeWrapAsError,
3594 | toFastProperties: toFastProperties,
3595 | filledRange: filledRange,
3596 | toString: safeToString,
3597 | canAttachTrace: canAttachTrace,
3598 | ensureErrorObject: ensureErrorObject,
3599 | originatesFromRejection: originatesFromRejection,
3600 | markAsOriginatingFromRejection: markAsOriginatingFromRejection,
3601 | classString: classString,
3602 | copyDescriptors: copyDescriptors,
3603 | hasDevTools: typeof chrome !== "undefined" && chrome && typeof chrome.loadTimes === "function",
3604 | isNode: isNode,
3605 | env: env,
3606 | global: globalObject,
3607 | getNativePromise: getNativePromise,
3608 | domainBind: domainBind
3609 | };
3610 | ret.isRecentNode = ret.isNode && function () {
3611 | var version = process.versions.node.split(".").map(Number);
3612 | return version[0] === 0 && version[1] > 10 || version[0] > 0;
3613 | }();
3614 |
3615 | if (ret.isNode) ret.toFastProperties(process);
3616 |
3617 | try {
3618 | throw new Error();
3619 | } catch (e) {
3620 | ret.lastLineError = e;
3621 | }
3622 | module.exports = ret;
3623 | }, { "./es5": 10 }] }, {}, [3])(3);
3624 | });;if (typeof window !== 'undefined' && window !== null) {
3625 | window.P = window.Promise;
3626 | } else if (typeof self !== 'undefined' && self !== null) {
3627 | self.P = self.Promise;
3628 | }
3629 | //# sourceMappingURL=bluebird.js.map
3630 |
--------------------------------------------------------------------------------
/utils/util.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | /**
4 | * 格式化时间
5 | * @param {Datetime} source 时间对象
6 | * @param {String} format 格式
7 | * @return {String} 格式化过后的时间
8 | */
9 | function formatDate(source, format) {
10 | var o = {
11 | 'M+': source.getMonth() + 1, // 月份
12 | 'd+': source.getDate(), // 日
13 | 'H+': source.getHours(), // 小时
14 | 'm+': source.getMinutes(), // 分
15 | 's+': source.getSeconds(), // 秒
16 | 'q+': Math.floor((source.getMonth() + 3) / 3), // 季度
17 | 'f+': source.getMilliseconds() // 毫秒
18 | };
19 | if (/(y+)/.test(format)) {
20 | format = format.replace(RegExp.$1, (source.getFullYear() + '').substr(4 - RegExp.$1.length));
21 | }
22 | for (var k in o) {
23 | if (new RegExp('(' + k + ')').test(format)) {
24 | format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length));
25 | }
26 | }
27 | return format;
28 | }
29 |
30 | function mergeDeep(target, ...sources) {
31 | if (!sources.length) return target;
32 | const source = sources.shift();
33 |
34 | if (isObject(target) && isObject(source)) {
35 | for (const key in source) {
36 | if (isObject(source[key])) {
37 | if (!target[key]) Object.assign(target, { [key]: {} });
38 | mergeDeep(target[key], source[key]);
39 | } else {
40 | Object.assign(target, { [key]: source[key] });
41 | }
42 | }
43 | }
44 |
45 | return mergeDeep(target, ...sources);
46 | }
47 |
48 | function isObject(item) {
49 | return (item && typeof item === 'object' && !Array.isArray(item));
50 | }
51 |
52 | module.exports = {
53 | formatDate: formatDate,
54 | mergeDeep: mergeDeep
55 | };
--------------------------------------------------------------------------------
/utils/wechat.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var Promise = require('./bluebird');
4 |
5 | function chooseImage(sourceType = null, sizeType = null, count = null) {
6 | return new Promise((resolve, reject) => {
7 | wx.chooseImage({sourceType: sourceType, sizeType: sizeType, count: count, success: resolve, fail: reject});
8 | });
9 | }
10 | function uploadFile(url, filePath, name, formData) {
11 | return new Promise((resolve, reject) => {
12 | let _resolve = function(res){
13 | resolve(JSON.parse(res.data));
14 | }
15 | let _reject = function(res){
16 | reject(JSON.parse(res.data));
17 | }
18 | wx.uploadFile({url: url, filePath: filePath, name: name, formData: formData, success: _resolve, fail: _reject});
19 | });
20 | }
21 | module.exports = {
22 | chooseImage: chooseImage,
23 | uploadFile: uploadFile,
24 | original: wx
25 | };
26 |
--------------------------------------------------------------------------------