1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
define("dojo/promise/Promise", [
"../_base/lang"
], function(lang){
"use strict";
// module:
// dojo/promise/Promise
function throwAbstract(){
throw new TypeError("abstract");
}
return lang.extend(function Promise(){
// summary:
// The public interface to a deferred.
// description:
// The public interface to a deferred. All promises in Dojo are
// instances of this class.
}, {
then: function(callback, errback, progback){
// summary:
// Add new callbacks to the promise.
// description:
// Add new callbacks to the deferred. Callbacks can be added
// before or after the deferred is fulfilled.
// callback: Function?
// Callback to be invoked when the promise is resolved.
// Receives the resolution value.
// errback: Function?
// Callback to be invoked when the promise is rejected.
// Receives the rejection error.
// progback: Function?
// Callback to be invoked when the promise emits a progress
// update. Receives the progress update.
// returns: dojo/promise/Promise
// Returns a new promise for the result of the callback(s).
// This can be used for chaining many asynchronous operations.
throwAbstract();
},
cancel: function(reason, strict){
// summary:
// Inform the deferred it may cancel its asynchronous operation.
// description:
// Inform the deferred it may cancel its asynchronous operation.
// The deferred's (optional) canceler is invoked and the
// deferred will be left in a rejected state. Can affect other
// promises that originate with the same deferred.
// reason: any
// A message that may be sent to the deferred's canceler,
// explaining why it's being canceled.
// strict: Boolean?
// If strict, will throw an error if the deferred has already
// been fulfilled and consequently cannot be canceled.
// returns: any
// Returns the rejection reason if the deferred was canceled
// normally.
throwAbstract();
},
isResolved: function(){
// summary:
// Checks whether the promise has been resolved.
// returns: Boolean
throwAbstract();
},
isRejected: function(){
// summary:
// Checks whether the promise has been rejected.
// returns: Boolean
throwAbstract();
},
isFulfilled: function(){
// summary:
// Checks whether the promise has been resolved or rejected.
// returns: Boolean
throwAbstract();
},
isCanceled: function(){
// summary:
// Checks whether the promise has been canceled.
// returns: Boolean
throwAbstract();
},
always: function(callbackOrErrback){
// summary:
// Add a callback to be invoked when the promise is resolved
// or rejected.
// callbackOrErrback: Function?
// A function that is used both as a callback and errback.
// returns: dojo/promise/Promise
// Returns a new promise for the result of the callback/errback.
return this.then(callbackOrErrback, callbackOrErrback);
},
otherwise: function(errback){
// summary:
// Add new errbacks to the promise.
// errback: Function?
// Callback to be invoked when the promise is rejected.
// returns: dojo/promise/Promise
// Returns a new promise for the result of the errback.
return this.then(null, errback);
},
trace: function(){
return this;
},
traceRejected: function(){
return this;
},
toString: function(){
// returns: string
// Returns `[object Promise]`.
return "[object Promise]";
}
});
});
|
