Lines Matching refs:promise
152 var promise = ret.promise();
156 return promise;
255 function AsyncSettlePromises(promise) { argument
256 this._normalQueue._pushOne(promise);
287 Async.prototype.settlePromises = function(promise) { argument
289 AsyncSettlePromises.call(this, promise);
292 promise._settlePromises();
373 promise: ret, property in Promise.bind.context
495 var promise = this;
496 var child = promise;
497 while (promise._isCancellable()) {
498 if (!promise._cancelBy(child)) {
507 var parent = promise._cancellationParent;
509 if (promise._isFollowing()) {
510 promise._followee().cancel();
512 promise._cancelBranched();
516 if (promise._isFollowing()) promise._followee().cancel();
517 promise._setWillBeCancelled();
518 child = promise;
519 promise = parent;
623 function catchFilter(instances, cb, promise) { argument
625 var boundTo = promise._boundValue();
828 Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) { argument
829 return warn(message, shouldUseOwnTrace, promise || this);
892 eventData, "promise", {value: event.promise});
905 es5.defineProperty(domEvent, "promise", {value: event.promise});
947 function generatePromiseLifecycleEventObject(name, promise) { argument
948 return {promise: promise};
957 promiseChained: function(name, promise, child) { argument
958 return {promise: promise, child: child};
963 unhandledRejection: function (name, reason, promise) { argument
964 return {reason: reason, promise: promise};
1063 var promise = this;
1070 promise._attachCancellationCallback(onCancel);
1165 function checkForgottenReturns(returnValue, promiseCreated, name, promise, argument
1170 if ((promise._bitField & 65535) === 0) return;
1208 promise._warn(msg, true, promiseCreated);
1219 function warn(message, shouldUseOwnTrace, promise) { argument
1224 promise._attachExtraTrace(warning);
1346 function fireRejectionEvent(name, localHandler, reason, promise) { argument
1352 localHandler(promise);
1354 localHandler(reason, promise);
1362 if (!activeFireEvent(name, reason, promise) && !localEventFired) {
1366 activeFireEvent(name, promise);
1968 function PassThroughHandlerContext(promise, type, handler) { argument
1969 this.promise = promise;
2002 return finallyHandler.call(this, this.promise._target()._settledValue());
2010 var promise = this.promise;
2016 ? handler.call(promise._boundValue())
2017 : handler.call(promise._boundValue(), reasonOrValue);
2021 promise._setReturnedNonUndefined();
2022 var maybePromise = tryConvertToPromise(ret, promise);
2028 promise._attachExtraTrace(reason);
2042 if (promise.isRejected()) {
2150 var promise = this._promise = new Promise(INTERNAL);
2151 promise._captureStackTrace();
2222 var promise = this._yieldedPromise;
2224 promise.cancel();
2228 PromiseSpawn.prototype.promise = function () { method in PromiseSpawn
2240 var promise = this._promise;
2244 return promise.cancel();
2246 return promise._rejectCallback(result.e, false);
2254 return promise.cancel();
2256 return promise._resolveCallback(value);
2307 var ret = spawn.promise();
2327 var ret = spawn.promise();
2355 var ret = new PromiseArray(args).promise();
2418 var promise = this._promise;
2420 var receiver = promise._boundValue();
2421 promise._pushContext();
2423 var promiseCreated = promise._popContext();
2428 promise
2517 return new MappingPromiseArray(promises, fn, limit, _filter).promise();
2622 function nodebackForPromise(promise, multiArgs) { argument
2624 if (promise === null) return;
2627 promise._attachExtraTrace(wrapped);
2628 promise._reject(wrapped);
2630 promise._fulfill(value);
2633 promise._fulfill(args);
2635 promise = null;
2650 var promise = this;
2651 if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
2653 tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
2660 var promise = this;
2661 var receiver = promise._boundValue();
2670 var promise = this;
2676 var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
2830 var promise =
2832 promise._setIsFinal();
2863 return new PromiseArray(this).promise();
2890 return new PromiseArray(promises).promise();
2927 var promise = haveInternalData ? internalData : new Promise(INTERNAL);
2932 promise._propagateFrom(this, 3);
2933 promise._captureStackTrace();
2942 this._fireEvent("promiseChained", this, promise);
2966 promise: promise,
2971 target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
2974 return promise;
3067 var promise = follower._promise0;
3070 this._addCallbacks(fulfill, reject, promise, receiver, null);
3076 var promise = follower._promiseAt(index);
3079 this._addCallbacks(fulfill, reject, promise, receiver, null);
3085 promise, argument
3097 this._promise0 = promise;
3109 this[base + 2] = promise;
3137 var promise = maybePromise._target();
3139 if (promise === this) {
3144 var bitField = promise._bitField;
3147 if (len > 0) promise._migrateCallback0(this);
3149 promise._migrateCallbackAt(this, i);
3153 this._setFollowee(promise);
3155 this._fulfill(promise._value());
3157 this._reject(promise._reason());
3160 promise._attachExtraTrace(reason);
3180 var promise = this;
3185 promise._resolveCallback(value);
3187 promise._rejectCallback(reason, synchronous);
3193 promise._rejectCallback(r, true);
3198 handler, receiver, value, promise argument
3200 var bitField = promise._bitField;
3202 promise._pushContext();
3215 var promiseCreated = promise._popContext();
3216 bitField = promise._bitField;
3220 promise._reject(value);
3222 promise._rejectCallback(x.e, false);
3224 debug.checkForgottenReturns(x, promiseCreated, "", promise, this);
3225 promise._resolveCallback(x);
3239 Promise.prototype._setFollowee = function(promise) { argument
3240 this._rejectionHandler0 = promise;
3243 Promise.prototype._settlePromise = function(promise, handler, receiver, value) { argument
3244 var isPromise = promise instanceof Promise;
3248 if (isPromise) promise._invokeInternalOnCancel();
3252 receiver.cancelPromise = promise;
3254 promise._reject(errorObj.e);
3257 promise._fulfill(reflectHandler.call(receiver));
3259 receiver._promiseCancelled(promise);
3260 } else if (isPromise || promise instanceof PromiseArray) {
3261 promise._cancel();
3267 handler.call(receiver, value, promise);
3269 if (asyncGuaranteed) promise._setAsyncGuaranteed();
3270 this._settlePromiseFromHandler(handler, receiver, value, promise);
3275 receiver._promiseFulfilled(value, promise);
3277 receiver._promiseRejected(value, promise);
3281 if (asyncGuaranteed) promise._setAsyncGuaranteed();
3283 promise._fulfill(value);
3285 promise._reject(value);
3292 var promise = ctx.promise;
3296 if (!(promise instanceof Promise)) {
3297 handler.call(receiver, value, promise);
3299 this._settlePromiseFromHandler(handler, receiver, value, promise);
3301 } else if (promise instanceof Promise) {
3302 promise._reject(value);
3307 this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
3311 var promise = this._promise0;
3315 this._settlePromise(promise, handler, receiver, value);
3367 var promise = this._promiseAt(i);
3370 this._settlePromise(promise, handler, receiver, value);
3377 var promise = this._promiseAt(i);
3380 this._settlePromise(promise, handler, receiver, reason);
3412 function deferResolve(v) {this.promise._resolveCallback(v);}
3413 function deferReject(v) {this.promise._rejectCallback(v, false);}
3417 var promise = new Promise(INTERNAL);
3419 promise: promise,
3495 var promise = this._promise = new Promise(INTERNAL);
3497 promise._propagateFrom(values, 3);
3499 promise._setOnCancel(this);
3511 PromiseArray.prototype.promise = function () { method in PromiseArray
3763 var promise = new Promise(INTERNAL);
3764 promise._captureStackTrace();
3767 var fn = nodebackForPromise(promise, multiArgs);
3771 promise._rejectCallback(maybeWrapAsError(e), true, true);
3773 if (!promise._isFateSealed()) promise._setAsyncGuaranteed();
3774 return promise;
3964 ret = new PropertiesPromiseArray(castValue).promise();
4063 var raceLater = function (promise) { argument
4064 return promise.then(function(array) {
4065 return race(array, promise);
4241 return array.promise();
4258 var promise = array._promise;
4260 promise._pushContext();
4263 ret = fn.call(promise._boundValue(), value, this.index, this.length);
4265 ret = fn.call(promise._boundValue(),
4271 var promiseCreated = promise._popContext();
4276 promise
4382 return new SettledPromiseArray(promises).promise();
4523 var promise = ret.promise();
4526 return promise;
4543 function PromiseInspection(promise) { argument
4544 if (promise !== undefined) {
4545 promise = promise._target();
4546 this._bitField = promise._bitField;
4547 this._settledValueField = promise._isFateSealed()
4548 ? promise._settledValue() : undefined;
4702 var promise = new Promise(INTERNAL);
4703 var ret = promise;
4705 promise._captureStackTrace();
4711 if (promise && result === errorObj) {
4712 promise._rejectCallback(result.e, true, true);
4713 promise = null;
4717 if (!promise) return;
4718 promise._resolveCallback(value);
4719 promise = null;
4723 if (!promise) return;
4724 promise._rejectCallback(reason, synchronous, true);
4725 promise = null;
4773 var afterTimeout = function (promise, message, parent) { argument
4785 promise._attachExtraTrace(err);
4786 promise._reject(err);
4865 resources.promise);
4880 function Disposer(data, promise, context) { argument
4882 this._promise = promise;
4890 Disposer.prototype.promise = function () { method in Disposer
4895 if (this.promise().isFulfilled()) {
4896 return this.promise().value();
4919 function FunctionDisposer(fn, promise, context) { argument
4920 this.constructor$(fn, promise, context);
4932 return value.promise();
4939 this.promise = null;
4976 resource = resource.promise();
5009 promise._pushContext();
5014 var promiseCreated = promise._popContext();
5016 ret, promiseCreated, "Promise.using", promise);
5020 var promise = resultPromise.lastly(function() {
5024 resources.promise = promise;
5025 promise._setOnCancel(resources);
5026 return promise;
5384 var promise = new Promise(function(){});
5385 if ({}.toString.call(promise) === "[object Promise]") {
11940 gantt.Promise = __webpack_require__(/*! ../utils/promise */ "./sources/utils/promise.js");