ember-source 1.7.0.beta.5 → 1.7.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/VERSION +1 -1
- data/dist/ember-runtime.js +1704 -1077
- data/dist/ember-tests.js +72 -15
- data/dist/ember.js +1853 -1126
- data/dist/ember.min.js +19 -19
- data/dist/ember.prod.js +1852 -1125
- metadata +4 -4
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 0d6ff9f4eb4af89c66ed6a548d9628eb0802e036
|
4
|
+
data.tar.gz: 783d7d84bea121ce0e42385938b415a8c367c346
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: f95ef7b9d2869b857bdfd4d25af936c8ca2ea75060d2cfe3565f54c63679331d2663797127fc71939aeff79e523a105b3fff621a1c7a241e787689f95fc780db
|
7
|
+
data.tar.gz: 8f9a3338317a2b772e26fe7ee5421784a04ef589b85fed97535a1849d2d5d7c5355c9ecbb5ec216e3c49dc28a989111cb6419693ff8c470272770e70cd242f2d
|
data/VERSION
CHANGED
@@ -1 +1 @@
|
|
1
|
-
1.7.0
|
1
|
+
1.7.0
|
data/dist/ember-runtime.js
CHANGED
@@ -5,7 +5,7 @@
|
|
5
5
|
* Portions Copyright 2008-2011 Apple Inc. All rights reserved.
|
6
6
|
* @license Licensed under MIT license
|
7
7
|
* See https://raw.github.com/emberjs/ember.js/master/LICENSE
|
8
|
-
* @version 1.7.0
|
8
|
+
* @version 1.7.0
|
9
9
|
*/
|
10
10
|
|
11
11
|
(function() {
|
@@ -868,6 +868,47 @@ define("backburner/utils",
|
|
868
868
|
};
|
869
869
|
});
|
870
870
|
|
871
|
+
define("calculateVersion",
|
872
|
+
[],
|
873
|
+
function() {
|
874
|
+
"use strict";
|
875
|
+
'use strict';
|
876
|
+
|
877
|
+
var fs = require('fs');
|
878
|
+
var path = require('path');
|
879
|
+
|
880
|
+
module.exports = function () {
|
881
|
+
var packageVersion = require('../package.json').version;
|
882
|
+
var output = [packageVersion];
|
883
|
+
var gitPath = path.join(__dirname,'..','.git');
|
884
|
+
var headFilePath = path.join(gitPath, 'HEAD');
|
885
|
+
|
886
|
+
if (packageVersion.indexOf('+') > -1) {
|
887
|
+
try {
|
888
|
+
if (fs.existsSync(headFilePath)) {
|
889
|
+
var headFile = fs.readFileSync(headFilePath, {encoding: 'utf8'});
|
890
|
+
var branchName = headFile.split('/').slice(-1)[0].trim();
|
891
|
+
var refPath = headFile.split(' ')[1];
|
892
|
+
var branchSHA;
|
893
|
+
|
894
|
+
if (refPath) {
|
895
|
+
var branchPath = path.join(gitPath, refPath.trim());
|
896
|
+
branchSHA = fs.readFileSync(branchPath);
|
897
|
+
} else {
|
898
|
+
branchSHA = branchName;
|
899
|
+
}
|
900
|
+
|
901
|
+
output.push(branchSHA.slice(0,10));
|
902
|
+
}
|
903
|
+
} catch (err) {
|
904
|
+
console.error(err.stack);
|
905
|
+
}
|
906
|
+
return output.join('.');
|
907
|
+
} else {
|
908
|
+
return packageVersion;
|
909
|
+
}
|
910
|
+
};
|
911
|
+
});
|
871
912
|
define("container",
|
872
913
|
["container/container","exports"],
|
873
914
|
function(__dependency1__, __exports__) {
|
@@ -2700,7 +2741,7 @@ define("ember-metal/binding",
|
|
2700
2741
|
|
2701
2742
|
Properties ending in a `Binding` suffix will be converted to `Ember.Binding`
|
2702
2743
|
instances. The value of this property should be a string representing a path
|
2703
|
-
to another object or a custom binding
|
2744
|
+
to another object or a custom binding instance created using Binding helpers
|
2704
2745
|
(see "One Way Bindings"):
|
2705
2746
|
|
2706
2747
|
```
|
@@ -2756,7 +2797,7 @@ define("ember-metal/binding",
|
|
2756
2797
|
something like this on your binding:
|
2757
2798
|
|
2758
2799
|
```javascript
|
2759
|
-
binding = Ember.Binding.from(
|
2800
|
+
binding = Ember.Binding.from("valueBinding").to("value");
|
2760
2801
|
```
|
2761
2802
|
|
2762
2803
|
This creates a new binding instance based on the template you provide, and
|
@@ -2773,6 +2814,19 @@ define("ember-metal/binding",
|
|
2773
2814
|
to side of the binding when inspecting relative paths. This allows the
|
2774
2815
|
binding to be automatically inherited by subclassed objects as well.
|
2775
2816
|
|
2817
|
+
This also allows you to bind between objects using the paths you declare in
|
2818
|
+
`from` and `to`:
|
2819
|
+
|
2820
|
+
```javascript
|
2821
|
+
// Example 1
|
2822
|
+
binding = Ember.Binding.from("App.someObject.value").to("value");
|
2823
|
+
binding.connect(this);
|
2824
|
+
|
2825
|
+
// Example 2
|
2826
|
+
binding = Ember.Binding.from("parentView.value").to("App.someObject.value");
|
2827
|
+
binding.connect(this);
|
2828
|
+
```
|
2829
|
+
|
2776
2830
|
Now that the binding is connected, it will observe both the from and to side
|
2777
2831
|
and relay changes.
|
2778
2832
|
|
@@ -3351,7 +3405,7 @@ define("ember-metal/computed",
|
|
3351
3405
|
@return {Ember.ComputedProperty} this
|
3352
3406
|
@chainable
|
3353
3407
|
*/
|
3354
|
-
ComputedPropertyPrototype
|
3408
|
+
ComputedPropertyPrototype.volatile = function() {
|
3355
3409
|
return this.cacheable(false);
|
3356
3410
|
};
|
3357
3411
|
|
@@ -3798,15 +3852,11 @@ define("ember-metal/computed_macros",
|
|
3798
3852
|
A computed property that returns true if the value of the dependent
|
3799
3853
|
property is NOT null, an empty string, empty array, or empty function.
|
3800
3854
|
|
3801
|
-
Note: When using `computed.notEmpty` to watch an array make sure to
|
3802
|
-
use the `array.[]` syntax so the computed can subscribe to transitions
|
3803
|
-
from empty to non-empty states.
|
3804
|
-
|
3805
3855
|
Example
|
3806
3856
|
|
3807
3857
|
```javascript
|
3808
3858
|
var Hamster = Ember.Object.extend({
|
3809
|
-
hasStuff: Ember.computed.notEmpty('backpack
|
3859
|
+
hasStuff: Ember.computed.notEmpty('backpack')
|
3810
3860
|
});
|
3811
3861
|
|
3812
3862
|
var hamster = Hamster.create({ backpack: ['Food', 'Sleeping Bag', 'Tent'] });
|
@@ -3822,9 +3872,11 @@ define("ember-metal/computed_macros",
|
|
3822
3872
|
@return {Ember.ComputedProperty} computed property which returns true if
|
3823
3873
|
original value for property is not empty.
|
3824
3874
|
*/
|
3825
|
-
|
3826
|
-
return
|
3827
|
-
|
3875
|
+
computed.notEmpty = function(dependentKey) {
|
3876
|
+
return computed(dependentKey + '.length', function () {
|
3877
|
+
return !isEmpty(get(this, dependentKey));
|
3878
|
+
});
|
3879
|
+
};
|
3828
3880
|
|
3829
3881
|
/**
|
3830
3882
|
A computed property that returns true if the value of the dependent
|
@@ -4405,6 +4457,7 @@ define("ember-metal/computed_macros",
|
|
4405
4457
|
@param {String} dependentKey
|
4406
4458
|
@return {Ember.ComputedProperty} computed property which creates an
|
4407
4459
|
alias with a deprecation to the original value for property.
|
4460
|
+
@since 1.7.0
|
4408
4461
|
*/
|
4409
4462
|
computed.deprecatingAlias = function(dependentKey) {
|
4410
4463
|
return computed(dependentKey, function(key, value) {
|
@@ -4447,7 +4500,7 @@ define("ember-metal/core",
|
|
4447
4500
|
|
4448
4501
|
@class Ember
|
4449
4502
|
@static
|
4450
|
-
@version 1.7.0
|
4503
|
+
@version 1.7.0
|
4451
4504
|
*/
|
4452
4505
|
|
4453
4506
|
if ('undefined' === typeof Ember) {
|
@@ -4474,10 +4527,10 @@ define("ember-metal/core",
|
|
4474
4527
|
/**
|
4475
4528
|
@property VERSION
|
4476
4529
|
@type String
|
4477
|
-
@default '1.7.0
|
4530
|
+
@default '1.7.0'
|
4478
4531
|
@static
|
4479
4532
|
*/
|
4480
|
-
Ember.VERSION = '1.7.0
|
4533
|
+
Ember.VERSION = '1.7.0';
|
4481
4534
|
|
4482
4535
|
/**
|
4483
4536
|
Standard environmental variables. You can define these in a global `EmberENV`
|
@@ -4514,7 +4567,7 @@ define("ember-metal/core",
|
|
4514
4567
|
MetamorphENV.DISABLE_RANGE_API = Ember.ENV.DISABLE_RANGE_API;
|
4515
4568
|
|
4516
4569
|
/**
|
4517
|
-
Hash of enabled Canary features. Add to before creating your application.
|
4570
|
+
Hash of enabled Canary features. Add to this before creating your application.
|
4518
4571
|
|
4519
4572
|
You can also define `ENV.FEATURES` if you need to enable features flagged at runtime.
|
4520
4573
|
|
@@ -7798,6 +7851,7 @@ define("ember-metal/properties",
|
|
7798
7851
|
@param {String} deprecatedKey The property to add (and print deprecation warnings upon accessing).
|
7799
7852
|
@param {String} newKey The property that will be aliased.
|
7800
7853
|
@private
|
7854
|
+
@since 1.7.0
|
7801
7855
|
*/
|
7802
7856
|
|
7803
7857
|
function deprecateProperty(object, deprecatedKey, newKey) {
|
@@ -11926,12 +11980,6 @@ define("ember-runtime/computed/reduce_computed_macros",
|
|
11926
11980
|
duplicated elements from the dependent arrays
|
11927
11981
|
*/
|
11928
11982
|
function intersect() {
|
11929
|
-
var getDependentKeyGuids = function (changeMeta) {
|
11930
|
-
return map(changeMeta.property._dependentKeys, function (dependentKey) {
|
11931
|
-
return guidFor(dependentKey);
|
11932
|
-
});
|
11933
|
-
};
|
11934
|
-
|
11935
11983
|
var args = a_slice.call(arguments);
|
11936
11984
|
args.push({
|
11937
11985
|
initialize: function (array, changeMeta, instanceMeta) {
|
@@ -11939,11 +11987,10 @@ define("ember-runtime/computed/reduce_computed_macros",
|
|
11939
11987
|
},
|
11940
11988
|
|
11941
11989
|
addedItem: function(array, item, changeMeta, instanceMeta) {
|
11942
|
-
var itemGuid = guidFor(item)
|
11943
|
-
|
11944
|
-
|
11945
|
-
|
11946
|
-
itemCounts = instanceMeta.itemCounts;
|
11990
|
+
var itemGuid = guidFor(item);
|
11991
|
+
var dependentGuid = guidFor(changeMeta.arrayChanged);
|
11992
|
+
var numberOfDependentArrays = changeMeta.property._dependentKeys.length;
|
11993
|
+
var itemCounts = instanceMeta.itemCounts;
|
11947
11994
|
|
11948
11995
|
if (!itemCounts[itemGuid]) { itemCounts[itemGuid] = {}; }
|
11949
11996
|
if (itemCounts[itemGuid][dependentGuid] === undefined) { itemCounts[itemGuid][dependentGuid] = 0; }
|
@@ -11956,14 +12003,16 @@ define("ember-runtime/computed/reduce_computed_macros",
|
|
11956
12003
|
return array;
|
11957
12004
|
},
|
11958
12005
|
removedItem: function(array, item, changeMeta, instanceMeta) {
|
11959
|
-
var itemGuid = guidFor(item)
|
11960
|
-
|
11961
|
-
|
11962
|
-
|
11963
|
-
|
11964
|
-
|
12006
|
+
var itemGuid = guidFor(item);
|
12007
|
+
var dependentGuid = guidFor(changeMeta.arrayChanged);
|
12008
|
+
var numberOfDependentArrays = changeMeta.property._dependentKeys.length;
|
12009
|
+
var numberOfArraysItemAppearsIn;
|
12010
|
+
var itemCounts = instanceMeta.itemCounts;
|
12011
|
+
|
12012
|
+
if (itemCounts[itemGuid][dependentGuid] === undefined) {
|
12013
|
+
itemCounts[itemGuid][dependentGuid] = 0;
|
12014
|
+
}
|
11965
12015
|
|
11966
|
-
if (itemCounts[itemGuid][dependentGuid] === undefined) { itemCounts[itemGuid][dependentGuid] = 0; }
|
11967
12016
|
if (--itemCounts[itemGuid][dependentGuid] === 0) {
|
11968
12017
|
delete itemCounts[itemGuid][dependentGuid];
|
11969
12018
|
numberOfArraysItemAppearsIn = keys(itemCounts[itemGuid]).length;
|
@@ -13103,7 +13152,7 @@ define("ember-runtime/keys",
|
|
13103
13152
|
if (key.substring(0,2) === '__') return;
|
13104
13153
|
if (key === '_super') return;
|
13105
13154
|
if (EnumerableUtils.indexOf(array, key) >= 0) return;
|
13106
|
-
if (
|
13155
|
+
if (!Object.prototype.hasOwnProperty.call(obj, key)) return;
|
13107
13156
|
|
13108
13157
|
array.push(key);
|
13109
13158
|
};
|
@@ -13912,7 +13961,18 @@ define("ember-runtime/mixins/controller",
|
|
13912
13961
|
|
13913
13962
|
store: null,
|
13914
13963
|
|
13964
|
+
/**
|
13965
|
+
The controller's current model. When retrieving or modifying a controller's
|
13966
|
+
model, this property should be used instead of the `content` property.
|
13967
|
+
|
13968
|
+
@property model
|
13969
|
+
@public
|
13970
|
+
*/
|
13915
13971
|
model: null,
|
13972
|
+
|
13973
|
+
/**
|
13974
|
+
@private
|
13975
|
+
*/
|
13916
13976
|
content: computed.alias('model'),
|
13917
13977
|
|
13918
13978
|
deprecatedSendHandles: function(actionName) {
|
@@ -13955,6 +14015,8 @@ define("ember-runtime/mixins/controller_content_model_alias_deprecation",
|
|
13955
14015
|
|
13956
14016
|
@class ControllerContentModelAliasDeprecation
|
13957
14017
|
@namespace Ember
|
14018
|
+
@private
|
14019
|
+
@since 1.7.0
|
13958
14020
|
*/
|
13959
14021
|
__exports__["default"] = Mixin.create({
|
13960
14022
|
/**
|
@@ -20563,226 +20625,370 @@ define("ember-runtime/system/tracked_array",
|
|
20563
20625
|
this.rangeStart = rangeStart;
|
20564
20626
|
}
|
20565
20627
|
});
|
20566
|
-
|
20567
|
-
|
20568
|
-
|
20569
|
-
|
20570
|
-
|
20571
|
-
|
20572
|
-
|
20573
|
-
|
20574
|
-
|
20575
|
-
|
20576
|
-
|
20628
|
+
define("rsvp",
|
20629
|
+
["./rsvp/promise","./rsvp/events","./rsvp/node","./rsvp/all","./rsvp/all-settled","./rsvp/race","./rsvp/hash","./rsvp/hash-settled","./rsvp/rethrow","./rsvp/defer","./rsvp/config","./rsvp/map","./rsvp/resolve","./rsvp/reject","./rsvp/filter","./rsvp/asap","exports"],
|
20630
|
+
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __exports__) {
|
20631
|
+
"use strict";
|
20632
|
+
var Promise = __dependency1__["default"];
|
20633
|
+
var EventTarget = __dependency2__["default"];
|
20634
|
+
var denodeify = __dependency3__["default"];
|
20635
|
+
var all = __dependency4__["default"];
|
20636
|
+
var allSettled = __dependency5__["default"];
|
20637
|
+
var race = __dependency6__["default"];
|
20638
|
+
var hash = __dependency7__["default"];
|
20639
|
+
var hashSettled = __dependency8__["default"];
|
20640
|
+
var rethrow = __dependency9__["default"];
|
20641
|
+
var defer = __dependency10__["default"];
|
20642
|
+
var config = __dependency11__.config;
|
20643
|
+
var configure = __dependency11__.configure;
|
20644
|
+
var map = __dependency12__["default"];
|
20645
|
+
var resolve = __dependency13__["default"];
|
20646
|
+
var reject = __dependency14__["default"];
|
20647
|
+
var filter = __dependency15__["default"];
|
20648
|
+
var asap = __dependency16__["default"];
|
20649
|
+
|
20650
|
+
config.async = asap; // default async is asap;
|
20651
|
+
var cast = resolve;
|
20652
|
+
function async(callback, arg) {
|
20653
|
+
config.async(callback, arg);
|
20654
|
+
}
|
20655
|
+
|
20656
|
+
function on() {
|
20657
|
+
config.on.apply(config, arguments);
|
20658
|
+
}
|
20659
|
+
|
20660
|
+
function off() {
|
20661
|
+
config.off.apply(config, arguments);
|
20662
|
+
}
|
20663
|
+
|
20664
|
+
// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
|
20665
|
+
if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {
|
20666
|
+
var callbacks = window['__PROMISE_INSTRUMENTATION__'];
|
20667
|
+
configure('instrument', true);
|
20668
|
+
for (var eventName in callbacks) {
|
20669
|
+
if (callbacks.hasOwnProperty(eventName)) {
|
20670
|
+
on(eventName, callbacks[eventName]);
|
20671
|
+
}
|
20672
|
+
}
|
20673
|
+
}
|
20674
|
+
|
20675
|
+
__exports__.cast = cast;
|
20676
|
+
__exports__.Promise = Promise;
|
20677
|
+
__exports__.EventTarget = EventTarget;
|
20678
|
+
__exports__.all = all;
|
20679
|
+
__exports__.allSettled = allSettled;
|
20680
|
+
__exports__.race = race;
|
20681
|
+
__exports__.hash = hash;
|
20682
|
+
__exports__.hashSettled = hashSettled;
|
20683
|
+
__exports__.rethrow = rethrow;
|
20684
|
+
__exports__.defer = defer;
|
20685
|
+
__exports__.denodeify = denodeify;
|
20686
|
+
__exports__.configure = configure;
|
20687
|
+
__exports__.on = on;
|
20688
|
+
__exports__.off = off;
|
20689
|
+
__exports__.resolve = resolve;
|
20690
|
+
__exports__.reject = reject;
|
20691
|
+
__exports__.async = async;
|
20692
|
+
__exports__.map = map;
|
20693
|
+
__exports__.filter = filter;
|
20694
|
+
});
|
20695
|
+
define("rsvp.umd",
|
20696
|
+
["./rsvp"],
|
20697
|
+
function(__dependency1__) {
|
20698
|
+
"use strict";
|
20699
|
+
var Promise = __dependency1__.Promise;
|
20700
|
+
var allSettled = __dependency1__.allSettled;
|
20701
|
+
var hash = __dependency1__.hash;
|
20702
|
+
var hashSettled = __dependency1__.hashSettled;
|
20703
|
+
var denodeify = __dependency1__.denodeify;
|
20704
|
+
var on = __dependency1__.on;
|
20705
|
+
var off = __dependency1__.off;
|
20706
|
+
var map = __dependency1__.map;
|
20707
|
+
var filter = __dependency1__.filter;
|
20708
|
+
var resolve = __dependency1__.resolve;
|
20709
|
+
var reject = __dependency1__.reject;
|
20710
|
+
var rethrow = __dependency1__.rethrow;
|
20711
|
+
var all = __dependency1__.all;
|
20712
|
+
var defer = __dependency1__.defer;
|
20713
|
+
var EventTarget = __dependency1__.EventTarget;
|
20714
|
+
var configure = __dependency1__.configure;
|
20715
|
+
var race = __dependency1__.race;
|
20716
|
+
var async = __dependency1__.async;
|
20717
|
+
|
20718
|
+
var RSVP = {
|
20719
|
+
'race': race,
|
20720
|
+
'Promise': Promise,
|
20721
|
+
'allSettled': allSettled,
|
20722
|
+
'hash': hash,
|
20723
|
+
'hashSettled': hashSettled,
|
20724
|
+
'denodeify': denodeify,
|
20725
|
+
'on': on,
|
20726
|
+
'off': off,
|
20727
|
+
'map': map,
|
20728
|
+
'filter': filter,
|
20729
|
+
'resolve': resolve,
|
20730
|
+
'reject': reject,
|
20731
|
+
'all': all,
|
20732
|
+
'rethrow': rethrow,
|
20733
|
+
'defer': defer,
|
20734
|
+
'EventTarget': EventTarget,
|
20735
|
+
'configure': configure,
|
20736
|
+
'async': async
|
20737
|
+
};
|
20738
|
+
|
20739
|
+
/* global define:true module:true window: true */
|
20740
|
+
if (typeof define === 'function' && define.amd) {
|
20741
|
+
define(function() { return RSVP; });
|
20742
|
+
} else if (typeof module !== 'undefined' && module.exports) {
|
20743
|
+
module.exports = RSVP;
|
20744
|
+
} else if (typeof this !== 'undefined') {
|
20745
|
+
this['RSVP'] = RSVP;
|
20746
|
+
}
|
20747
|
+
});
|
20748
|
+
define("rsvp/-internal",
|
20749
|
+
["./utils","./instrument","./config","exports"],
|
20750
|
+
function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
|
20751
|
+
"use strict";
|
20577
20752
|
var objectOrFunction = __dependency1__.objectOrFunction;
|
20578
20753
|
var isFunction = __dependency1__.isFunction;
|
20579
|
-
|
20580
|
-
var instrument = __dependency2__[
|
20754
|
+
|
20755
|
+
var instrument = __dependency2__["default"];
|
20756
|
+
|
20581
20757
|
var config = __dependency3__.config;
|
20582
|
-
|
20583
|
-
}
|
20584
|
-
|
20758
|
+
|
20759
|
+
function noop() {}
|
20760
|
+
|
20761
|
+
var PENDING = void 0;
|
20585
20762
|
var FULFILLED = 1;
|
20586
|
-
var REJECTED
|
20763
|
+
var REJECTED = 2;
|
20764
|
+
|
20587
20765
|
var GET_THEN_ERROR = new ErrorObject();
|
20766
|
+
|
20588
20767
|
function getThen(promise) {
|
20589
|
-
|
20590
|
-
|
20591
|
-
|
20592
|
-
|
20593
|
-
|
20594
|
-
|
20768
|
+
try {
|
20769
|
+
return promise.then;
|
20770
|
+
} catch(error) {
|
20771
|
+
GET_THEN_ERROR.error = error;
|
20772
|
+
return GET_THEN_ERROR;
|
20773
|
+
}
|
20595
20774
|
}
|
20775
|
+
|
20596
20776
|
function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
|
20597
|
-
|
20598
|
-
|
20599
|
-
|
20600
|
-
|
20601
|
-
|
20777
|
+
try {
|
20778
|
+
then.call(value, fulfillmentHandler, rejectionHandler);
|
20779
|
+
} catch(e) {
|
20780
|
+
return e;
|
20781
|
+
}
|
20602
20782
|
}
|
20783
|
+
|
20603
20784
|
function handleForeignThenable(promise, thenable, then) {
|
20604
|
-
|
20605
|
-
|
20606
|
-
|
20607
|
-
|
20608
|
-
|
20609
|
-
|
20610
|
-
|
20611
|
-
|
20612
|
-
|
20613
|
-
|
20614
|
-
|
20615
|
-
|
20616
|
-
|
20617
|
-
|
20618
|
-
|
20619
|
-
|
20620
|
-
|
20621
|
-
|
20622
|
-
|
20623
|
-
|
20624
|
-
|
20625
|
-
|
20626
|
-
}
|
20627
|
-
}, promise);
|
20785
|
+
config.async(function(promise) {
|
20786
|
+
var sealed = false;
|
20787
|
+
var error = tryThen(then, thenable, function(value) {
|
20788
|
+
if (sealed) { return; }
|
20789
|
+
sealed = true;
|
20790
|
+
if (thenable !== value) {
|
20791
|
+
resolve(promise, value);
|
20792
|
+
} else {
|
20793
|
+
fulfill(promise, value);
|
20794
|
+
}
|
20795
|
+
}, function(reason) {
|
20796
|
+
if (sealed) { return; }
|
20797
|
+
sealed = true;
|
20798
|
+
|
20799
|
+
reject(promise, reason);
|
20800
|
+
}, 'Settle: ' + (promise._label || ' unknown promise'));
|
20801
|
+
|
20802
|
+
if (!sealed && error) {
|
20803
|
+
sealed = true;
|
20804
|
+
reject(promise, error);
|
20805
|
+
}
|
20806
|
+
}, promise);
|
20628
20807
|
}
|
20808
|
+
|
20629
20809
|
function handleOwnThenable(promise, thenable) {
|
20630
|
-
|
20631
|
-
|
20632
|
-
|
20633
|
-
|
20634
|
-
|
20635
|
-
|
20636
|
-
|
20637
|
-
|
20638
|
-
|
20639
|
-
|
20640
|
-
|
20641
|
-
|
20642
|
-
|
20643
|
-
|
20644
|
-
|
20645
|
-
}
|
20810
|
+
if (thenable._state === FULFILLED) {
|
20811
|
+
fulfill(promise, thenable._result);
|
20812
|
+
} else if (promise._state === REJECTED) {
|
20813
|
+
reject(promise, thenable._result);
|
20814
|
+
} else {
|
20815
|
+
subscribe(thenable, undefined, function(value) {
|
20816
|
+
if (thenable !== value) {
|
20817
|
+
resolve(promise, value);
|
20818
|
+
} else {
|
20819
|
+
fulfill(promise, value);
|
20820
|
+
}
|
20821
|
+
}, function(reason) {
|
20822
|
+
reject(promise, reason);
|
20823
|
+
});
|
20824
|
+
}
|
20646
20825
|
}
|
20826
|
+
|
20647
20827
|
function handleMaybeThenable(promise, maybeThenable) {
|
20648
|
-
|
20649
|
-
|
20828
|
+
if (maybeThenable.constructor === promise.constructor) {
|
20829
|
+
handleOwnThenable(promise, maybeThenable);
|
20830
|
+
} else {
|
20831
|
+
var then = getThen(maybeThenable);
|
20832
|
+
|
20833
|
+
if (then === GET_THEN_ERROR) {
|
20834
|
+
reject(promise, GET_THEN_ERROR.error);
|
20835
|
+
} else if (then === undefined) {
|
20836
|
+
fulfill(promise, maybeThenable);
|
20837
|
+
} else if (isFunction(then)) {
|
20838
|
+
handleForeignThenable(promise, maybeThenable, then);
|
20650
20839
|
} else {
|
20651
|
-
|
20652
|
-
if (then === GET_THEN_ERROR) {
|
20653
|
-
reject(promise, GET_THEN_ERROR.error);
|
20654
|
-
} else if (then === undefined) {
|
20655
|
-
fulfill(promise, maybeThenable);
|
20656
|
-
} else if (isFunction(then)) {
|
20657
|
-
handleForeignThenable(promise, maybeThenable, then);
|
20658
|
-
} else {
|
20659
|
-
fulfill(promise, maybeThenable);
|
20660
|
-
}
|
20840
|
+
fulfill(promise, maybeThenable);
|
20661
20841
|
}
|
20842
|
+
}
|
20662
20843
|
}
|
20844
|
+
|
20663
20845
|
function resolve(promise, value) {
|
20664
|
-
|
20665
|
-
|
20666
|
-
|
20667
|
-
|
20668
|
-
|
20669
|
-
|
20670
|
-
|
20846
|
+
if (promise === value) {
|
20847
|
+
fulfill(promise, value);
|
20848
|
+
} else if (objectOrFunction(value)) {
|
20849
|
+
handleMaybeThenable(promise, value);
|
20850
|
+
} else {
|
20851
|
+
fulfill(promise, value);
|
20852
|
+
}
|
20671
20853
|
}
|
20854
|
+
|
20672
20855
|
function publishRejection(promise) {
|
20673
|
-
|
20674
|
-
|
20675
|
-
|
20676
|
-
|
20856
|
+
if (promise._onerror) {
|
20857
|
+
promise._onerror(promise._result);
|
20858
|
+
}
|
20859
|
+
|
20860
|
+
publish(promise);
|
20677
20861
|
}
|
20862
|
+
|
20678
20863
|
function fulfill(promise, value) {
|
20679
|
-
|
20680
|
-
|
20681
|
-
|
20682
|
-
|
20683
|
-
|
20684
|
-
|
20685
|
-
|
20686
|
-
|
20687
|
-
}
|
20688
|
-
} else {
|
20689
|
-
config.async(publish, promise);
|
20864
|
+
if (promise._state !== PENDING) { return; }
|
20865
|
+
|
20866
|
+
promise._result = value;
|
20867
|
+
promise._state = FULFILLED;
|
20868
|
+
|
20869
|
+
if (promise._subscribers.length === 0) {
|
20870
|
+
if (config.instrument) {
|
20871
|
+
instrument('fulfilled', promise);
|
20690
20872
|
}
|
20873
|
+
} else {
|
20874
|
+
config.async(publish, promise);
|
20875
|
+
}
|
20691
20876
|
}
|
20877
|
+
|
20692
20878
|
function reject(promise, reason) {
|
20693
|
-
|
20694
|
-
|
20695
|
-
|
20696
|
-
|
20697
|
-
|
20698
|
-
config.async(publishRejection, promise);
|
20879
|
+
if (promise._state !== PENDING) { return; }
|
20880
|
+
promise._state = REJECTED;
|
20881
|
+
promise._result = reason;
|
20882
|
+
|
20883
|
+
config.async(publishRejection, promise);
|
20699
20884
|
}
|
20885
|
+
|
20700
20886
|
function subscribe(parent, child, onFulfillment, onRejection) {
|
20701
|
-
|
20702
|
-
|
20703
|
-
|
20704
|
-
|
20705
|
-
|
20706
|
-
|
20707
|
-
|
20708
|
-
|
20709
|
-
|
20887
|
+
var subscribers = parent._subscribers;
|
20888
|
+
var length = subscribers.length;
|
20889
|
+
|
20890
|
+
parent._onerror = null;
|
20891
|
+
|
20892
|
+
subscribers[length] = child;
|
20893
|
+
subscribers[length + FULFILLED] = onFulfillment;
|
20894
|
+
subscribers[length + REJECTED] = onRejection;
|
20895
|
+
|
20896
|
+
if (length === 0 && parent._state) {
|
20897
|
+
config.async(publish, parent);
|
20898
|
+
}
|
20710
20899
|
}
|
20900
|
+
|
20711
20901
|
function publish(promise) {
|
20712
|
-
|
20713
|
-
|
20714
|
-
|
20715
|
-
|
20716
|
-
|
20717
|
-
|
20718
|
-
|
20719
|
-
|
20720
|
-
|
20721
|
-
|
20722
|
-
|
20723
|
-
|
20724
|
-
|
20725
|
-
|
20726
|
-
|
20727
|
-
|
20728
|
-
|
20902
|
+
var subscribers = promise._subscribers;
|
20903
|
+
var settled = promise._state;
|
20904
|
+
|
20905
|
+
if (config.instrument) {
|
20906
|
+
instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
|
20907
|
+
}
|
20908
|
+
|
20909
|
+
if (subscribers.length === 0) { return; }
|
20910
|
+
|
20911
|
+
var child, callback, detail = promise._result;
|
20912
|
+
|
20913
|
+
for (var i = 0; i < subscribers.length; i += 3) {
|
20914
|
+
child = subscribers[i];
|
20915
|
+
callback = subscribers[i + settled];
|
20916
|
+
|
20917
|
+
if (child) {
|
20918
|
+
invokeCallback(settled, child, callback, detail);
|
20919
|
+
} else {
|
20920
|
+
callback(detail);
|
20729
20921
|
}
|
20730
|
-
|
20922
|
+
}
|
20923
|
+
|
20924
|
+
promise._subscribers.length = 0;
|
20731
20925
|
}
|
20926
|
+
|
20732
20927
|
function ErrorObject() {
|
20733
|
-
|
20928
|
+
this.error = null;
|
20734
20929
|
}
|
20930
|
+
|
20735
20931
|
var TRY_CATCH_ERROR = new ErrorObject();
|
20932
|
+
|
20736
20933
|
function tryCatch(callback, detail) {
|
20737
|
-
|
20738
|
-
|
20739
|
-
|
20740
|
-
|
20741
|
-
|
20742
|
-
|
20934
|
+
try {
|
20935
|
+
return callback(detail);
|
20936
|
+
} catch(e) {
|
20937
|
+
TRY_CATCH_ERROR.error = e;
|
20938
|
+
return TRY_CATCH_ERROR;
|
20939
|
+
}
|
20743
20940
|
}
|
20941
|
+
|
20744
20942
|
function invokeCallback(settled, promise, callback, detail) {
|
20745
|
-
|
20746
|
-
|
20747
|
-
|
20748
|
-
|
20749
|
-
|
20750
|
-
|
20751
|
-
|
20752
|
-
|
20753
|
-
|
20754
|
-
|
20755
|
-
if (promise === value) {
|
20756
|
-
reject(promise, new TypeError('A promises callback cannot return that same promise.'));
|
20757
|
-
return;
|
20758
|
-
}
|
20943
|
+
var hasCallback = isFunction(callback),
|
20944
|
+
value, error, succeeded, failed;
|
20945
|
+
|
20946
|
+
if (hasCallback) {
|
20947
|
+
value = tryCatch(callback, detail);
|
20948
|
+
|
20949
|
+
if (value === TRY_CATCH_ERROR) {
|
20950
|
+
failed = true;
|
20951
|
+
error = value.error;
|
20952
|
+
value = null;
|
20759
20953
|
} else {
|
20760
|
-
|
20761
|
-
succeeded = true;
|
20954
|
+
succeeded = true;
|
20762
20955
|
}
|
20763
|
-
|
20764
|
-
|
20765
|
-
|
20766
|
-
|
20767
|
-
} else if (failed) {
|
20768
|
-
reject(promise, error);
|
20769
|
-
} else if (settled === FULFILLED) {
|
20770
|
-
fulfill(promise, value);
|
20771
|
-
} else if (settled === REJECTED) {
|
20772
|
-
reject(promise, value);
|
20956
|
+
|
20957
|
+
if (promise === value) {
|
20958
|
+
reject(promise, new TypeError('A promises callback cannot return that same promise.'));
|
20959
|
+
return;
|
20773
20960
|
}
|
20961
|
+
|
20962
|
+
} else {
|
20963
|
+
value = detail;
|
20964
|
+
succeeded = true;
|
20965
|
+
}
|
20966
|
+
|
20967
|
+
if (promise._state !== PENDING) {
|
20968
|
+
// noop
|
20969
|
+
} else if (hasCallback && succeeded) {
|
20970
|
+
resolve(promise, value);
|
20971
|
+
} else if (failed) {
|
20972
|
+
reject(promise, error);
|
20973
|
+
} else if (settled === FULFILLED) {
|
20974
|
+
fulfill(promise, value);
|
20975
|
+
} else if (settled === REJECTED) {
|
20976
|
+
reject(promise, value);
|
20977
|
+
}
|
20774
20978
|
}
|
20979
|
+
|
20775
20980
|
function initializePromise(promise, resolver) {
|
20776
|
-
|
20777
|
-
|
20778
|
-
|
20779
|
-
|
20780
|
-
|
20781
|
-
|
20782
|
-
|
20783
|
-
|
20784
|
-
|
20981
|
+
try {
|
20982
|
+
resolver(function resolvePromise(value){
|
20983
|
+
resolve(promise, value);
|
20984
|
+
}, function rejectPromise(reason) {
|
20985
|
+
reject(promise, reason);
|
20986
|
+
});
|
20987
|
+
} catch(e) {
|
20988
|
+
reject(promise, e);
|
20989
|
+
}
|
20785
20990
|
}
|
20991
|
+
|
20786
20992
|
__exports__.noop = noop;
|
20787
20993
|
__exports__.resolve = resolve;
|
20788
20994
|
__exports__.reject = reject;
|
@@ -20794,27 +21000,28 @@ define('rsvp/-internal', [
|
|
20794
21000
|
__exports__.invokeCallback = invokeCallback;
|
20795
21001
|
__exports__.FULFILLED = FULFILLED;
|
20796
21002
|
__exports__.REJECTED = REJECTED;
|
20797
|
-
|
20798
|
-
|
20799
|
-
|
20800
|
-
|
20801
|
-
|
20802
|
-
|
20803
|
-
|
20804
|
-
'use strict';
|
20805
|
-
var Enumerator = __dependency1__['default'];
|
21003
|
+
__exports__.PENDING = PENDING;
|
21004
|
+
});
|
21005
|
+
define("rsvp/all-settled",
|
21006
|
+
["./enumerator","./promise","./utils","exports"],
|
21007
|
+
function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
|
21008
|
+
"use strict";
|
21009
|
+
var Enumerator = __dependency1__["default"];
|
20806
21010
|
var makeSettledResult = __dependency1__.makeSettledResult;
|
20807
|
-
var Promise = __dependency2__[
|
21011
|
+
var Promise = __dependency2__["default"];
|
20808
21012
|
var o_create = __dependency3__.o_create;
|
21013
|
+
|
20809
21014
|
function AllSettled(Constructor, entries, label) {
|
20810
|
-
|
21015
|
+
this._superConstructor(Constructor, entries, false /* don't abort on reject */, label);
|
20811
21016
|
}
|
21017
|
+
|
20812
21018
|
AllSettled.prototype = o_create(Enumerator.prototype);
|
20813
21019
|
AllSettled.prototype._superConstructor = Enumerator;
|
20814
21020
|
AllSettled.prototype._makeResult = makeSettledResult;
|
20815
|
-
AllSettled.prototype._validationError = function
|
20816
|
-
|
21021
|
+
AllSettled.prototype._validationError = function() {
|
21022
|
+
return new Error('allSettled must be called with an array');
|
20817
21023
|
};
|
21024
|
+
|
20818
21025
|
/**
|
20819
21026
|
`RSVP.allSettled` is similar to `RSVP.all`, but instead of implementing
|
20820
21027
|
a fail-fast method, it waits until all the promises have returned and
|
@@ -20849,8 +21056,8 @@ define('rsvp/all-settled', [
|
|
20849
21056
|
// { state: 'rejected', reason: Error },
|
20850
21057
|
// { state: 'rejected', reason: Error }
|
20851
21058
|
// ]
|
20852
|
-
// Note that for the second item, reason.message will be
|
20853
|
-
// third item, reason.message will be
|
21059
|
+
// Note that for the second item, reason.message will be '2', and for the
|
21060
|
+
// third item, reason.message will be '3'.
|
20854
21061
|
}, function(error) {
|
20855
21062
|
// Not run. (This block would only be called if allSettled had failed,
|
20856
21063
|
// for instance if passed an incorrect argument type.)
|
@@ -20866,16 +21073,17 @@ define('rsvp/all-settled', [
|
|
20866
21073
|
@return {Promise} promise that is fulfilled with an array of the settled
|
20867
21074
|
states of the constituent promises.
|
20868
21075
|
*/
|
20869
|
-
|
20870
|
-
|
20871
|
-
|
20872
|
-
}
|
20873
|
-
|
20874
|
-
|
20875
|
-
|
20876
|
-
|
20877
|
-
|
20878
|
-
var Promise = __dependency1__[
|
21076
|
+
|
21077
|
+
__exports__["default"] = function allSettled(entries, label) {
|
21078
|
+
return new AllSettled(Promise, entries, label).promise;
|
21079
|
+
}
|
21080
|
+
});
|
21081
|
+
define("rsvp/all",
|
21082
|
+
["./promise","exports"],
|
21083
|
+
function(__dependency1__, __exports__) {
|
21084
|
+
"use strict";
|
21085
|
+
var Promise = __dependency1__["default"];
|
21086
|
+
|
20879
21087
|
/**
|
20880
21088
|
This is a convenient alias for `RSVP.Promise.all`.
|
20881
21089
|
|
@@ -20886,110 +21094,134 @@ define('rsvp/all', [
|
|
20886
21094
|
@param {String} label An optional label. This is useful
|
20887
21095
|
for tooling.
|
20888
21096
|
*/
|
20889
|
-
__exports__[
|
20890
|
-
|
20891
|
-
}
|
20892
|
-
});
|
20893
|
-
define(
|
20894
|
-
|
20895
|
-
|
20896
|
-
|
20897
|
-
|
20898
|
-
|
20899
|
-
|
20900
|
-
|
20901
|
-
|
20902
|
-
|
20903
|
-
|
20904
|
-
|
20905
|
-
|
20906
|
-
|
20907
|
-
|
21097
|
+
__exports__["default"] = function all(array, label) {
|
21098
|
+
return Promise.all(array, label);
|
21099
|
+
}
|
21100
|
+
});
|
21101
|
+
define("rsvp/asap",
|
21102
|
+
["exports"],
|
21103
|
+
function(__exports__) {
|
21104
|
+
"use strict";
|
21105
|
+
var len = 0;
|
21106
|
+
|
21107
|
+
__exports__["default"] = function asap(callback, arg) {
|
21108
|
+
queue[len] = callback;
|
21109
|
+
queue[len + 1] = arg;
|
21110
|
+
len += 2;
|
21111
|
+
if (len === 2) {
|
21112
|
+
// If len is 1, that means that we need to schedule an async flush.
|
21113
|
+
// If additional callbacks are queued before the queue is flushed, they
|
21114
|
+
// will be processed by this flush that we are scheduling.
|
21115
|
+
scheduleFlush();
|
21116
|
+
}
|
21117
|
+
}
|
21118
|
+
|
21119
|
+
var browserGlobal = (typeof window !== 'undefined') ? window : {};
|
20908
21120
|
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
|
21121
|
+
|
20909
21122
|
// test for web worker but not in IE10
|
20910
|
-
var isWorker = typeof Uint8ClampedArray !== 'undefined' &&
|
21123
|
+
var isWorker = typeof Uint8ClampedArray !== 'undefined' &&
|
21124
|
+
typeof importScripts !== 'undefined' &&
|
21125
|
+
typeof MessageChannel !== 'undefined';
|
21126
|
+
|
20911
21127
|
// node
|
20912
21128
|
function useNextTick() {
|
20913
|
-
|
20914
|
-
|
20915
|
-
|
21129
|
+
return function() {
|
21130
|
+
process.nextTick(flush);
|
21131
|
+
};
|
20916
21132
|
}
|
21133
|
+
|
20917
21134
|
function useMutationObserver() {
|
20918
|
-
|
20919
|
-
|
20920
|
-
|
20921
|
-
|
20922
|
-
|
20923
|
-
|
20924
|
-
|
21135
|
+
var iterations = 0;
|
21136
|
+
var observer = new BrowserMutationObserver(flush);
|
21137
|
+
var node = document.createTextNode('');
|
21138
|
+
observer.observe(node, { characterData: true });
|
21139
|
+
|
21140
|
+
return function() {
|
21141
|
+
node.data = (iterations = ++iterations % 2);
|
21142
|
+
};
|
20925
21143
|
}
|
21144
|
+
|
20926
21145
|
// web worker
|
20927
21146
|
function useMessageChannel() {
|
20928
|
-
|
20929
|
-
|
20930
|
-
|
20931
|
-
|
20932
|
-
|
21147
|
+
var channel = new MessageChannel();
|
21148
|
+
channel.port1.onmessage = flush;
|
21149
|
+
return function () {
|
21150
|
+
channel.port2.postMessage(0);
|
21151
|
+
};
|
20933
21152
|
}
|
21153
|
+
|
20934
21154
|
function useSetTimeout() {
|
20935
|
-
|
20936
|
-
|
20937
|
-
|
21155
|
+
return function() {
|
21156
|
+
setTimeout(flush, 1);
|
21157
|
+
};
|
20938
21158
|
}
|
21159
|
+
|
20939
21160
|
var queue = new Array(1000);
|
20940
21161
|
function flush() {
|
20941
|
-
|
20942
|
-
|
20943
|
-
|
20944
|
-
|
20945
|
-
|
20946
|
-
|
20947
|
-
|
20948
|
-
|
21162
|
+
for (var i = 0; i < len; i+=2) {
|
21163
|
+
var callback = queue[i];
|
21164
|
+
var arg = queue[i+1];
|
21165
|
+
|
21166
|
+
callback(arg);
|
21167
|
+
|
21168
|
+
queue[i] = undefined;
|
21169
|
+
queue[i+1] = undefined;
|
21170
|
+
}
|
21171
|
+
|
21172
|
+
len = 0;
|
20949
21173
|
}
|
21174
|
+
|
20950
21175
|
var scheduleFlush;
|
21176
|
+
|
20951
21177
|
// Decide what async method to use to triggering processing of queued callbacks:
|
20952
21178
|
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
|
20953
|
-
|
21179
|
+
scheduleFlush = useNextTick();
|
20954
21180
|
} else if (BrowserMutationObserver) {
|
20955
|
-
|
21181
|
+
scheduleFlush = useMutationObserver();
|
20956
21182
|
} else if (isWorker) {
|
20957
|
-
|
21183
|
+
scheduleFlush = useMessageChannel();
|
20958
21184
|
} else {
|
20959
|
-
|
21185
|
+
scheduleFlush = useSetTimeout();
|
20960
21186
|
}
|
20961
|
-
});
|
20962
|
-
define(
|
20963
|
-
|
20964
|
-
|
20965
|
-
|
20966
|
-
|
20967
|
-
|
20968
|
-
var config = {
|
21187
|
+
});
|
21188
|
+
define("rsvp/config",
|
21189
|
+
["./events","exports"],
|
21190
|
+
function(__dependency1__, __exports__) {
|
21191
|
+
"use strict";
|
21192
|
+
var EventTarget = __dependency1__["default"];
|
21193
|
+
|
21194
|
+
var config = {
|
21195
|
+
instrument: false
|
21196
|
+
};
|
21197
|
+
|
20969
21198
|
EventTarget.mixin(config);
|
21199
|
+
|
20970
21200
|
function configure(name, value) {
|
20971
|
-
|
20972
|
-
|
20973
|
-
|
20974
|
-
|
20975
|
-
|
20976
|
-
|
20977
|
-
|
20978
|
-
|
20979
|
-
|
20980
|
-
|
20981
|
-
|
20982
|
-
|
21201
|
+
if (name === 'onerror') {
|
21202
|
+
// handle for legacy users that expect the actual
|
21203
|
+
// error to be passed to their function added via
|
21204
|
+
// `RSVP.configure('onerror', someFunctionHere);`
|
21205
|
+
config.on('error', value);
|
21206
|
+
return;
|
21207
|
+
}
|
21208
|
+
|
21209
|
+
if (arguments.length === 2) {
|
21210
|
+
config[name] = value;
|
21211
|
+
} else {
|
21212
|
+
return config[name];
|
21213
|
+
}
|
20983
21214
|
}
|
21215
|
+
|
20984
21216
|
__exports__.config = config;
|
20985
21217
|
__exports__.configure = configure;
|
20986
|
-
});
|
20987
|
-
define(
|
20988
|
-
|
20989
|
-
|
20990
|
-
|
20991
|
-
|
20992
|
-
|
21218
|
+
});
|
21219
|
+
define("rsvp/defer",
|
21220
|
+
["./promise","exports"],
|
21221
|
+
function(__dependency1__, __exports__) {
|
21222
|
+
"use strict";
|
21223
|
+
var Promise = __dependency1__["default"];
|
21224
|
+
|
20993
21225
|
/**
|
20994
21226
|
`RSVP.defer` returns an object similar to jQuery's `$.Deferred`.
|
20995
21227
|
`RSVP.defer` should be used when porting over code reliant on `$.Deferred`'s
|
@@ -21022,23 +21254,25 @@ define('rsvp/defer', [
|
|
21022
21254
|
Useful for tooling.
|
21023
21255
|
@return {Object}
|
21024
21256
|
*/
|
21025
|
-
|
21026
|
-
|
21027
|
-
|
21028
|
-
|
21029
|
-
|
21030
|
-
|
21031
|
-
|
21032
|
-
|
21033
|
-
|
21034
|
-
|
21035
|
-
|
21036
|
-
|
21037
|
-
|
21038
|
-
|
21039
|
-
|
21257
|
+
|
21258
|
+
__exports__["default"] = function defer(label) {
|
21259
|
+
var deferred = { };
|
21260
|
+
|
21261
|
+
deferred.promise = new Promise(function(resolve, reject) {
|
21262
|
+
deferred.resolve = resolve;
|
21263
|
+
deferred.reject = reject;
|
21264
|
+
}, label);
|
21265
|
+
|
21266
|
+
return deferred;
|
21267
|
+
}
|
21268
|
+
});
|
21269
|
+
define("rsvp/enumerator",
|
21270
|
+
["./utils","./-internal","exports"],
|
21271
|
+
function(__dependency1__, __dependency2__, __exports__) {
|
21272
|
+
"use strict";
|
21040
21273
|
var isArray = __dependency1__.isArray;
|
21041
21274
|
var isMaybeThenable = __dependency1__.isMaybeThenable;
|
21275
|
+
|
21042
21276
|
var noop = __dependency2__.noop;
|
21043
21277
|
var reject = __dependency2__.reject;
|
21044
21278
|
var fulfill = __dependency2__.fulfill;
|
@@ -21046,173 +21280,331 @@ define('rsvp/enumerator', [
|
|
21046
21280
|
var FULFILLED = __dependency2__.FULFILLED;
|
21047
21281
|
var REJECTED = __dependency2__.REJECTED;
|
21048
21282
|
var PENDING = __dependency2__.PENDING;
|
21049
|
-
|
21050
|
-
__exports__.ABORT_ON_REJECTION = ABORT_ON_REJECTION;
|
21283
|
+
|
21051
21284
|
function makeSettledResult(state, position, value) {
|
21052
|
-
|
21053
|
-
|
21054
|
-
|
21055
|
-
|
21056
|
-
|
21057
|
-
|
21058
|
-
|
21059
|
-
|
21060
|
-
|
21061
|
-
|
21062
|
-
|
21063
|
-
}
|
21064
|
-
|
21065
|
-
function Enumerator(Constructor, input, abortOnReject, label) {
|
21066
|
-
|
21067
|
-
|
21068
|
-
|
21069
|
-
|
21070
|
-
|
21071
|
-
|
21072
|
-
|
21073
|
-
|
21074
|
-
|
21075
|
-
|
21076
|
-
|
21077
|
-
|
21078
|
-
|
21079
|
-
if (this._remaining === 0) {
|
21080
|
-
fulfill(this.promise, this._result);
|
21081
|
-
}
|
21082
|
-
}
|
21285
|
+
if (state === FULFILLED) {
|
21286
|
+
return {
|
21287
|
+
state: 'fulfilled',
|
21288
|
+
value: value
|
21289
|
+
};
|
21290
|
+
} else {
|
21291
|
+
return {
|
21292
|
+
state: 'rejected',
|
21293
|
+
reason: value
|
21294
|
+
};
|
21295
|
+
}
|
21296
|
+
}
|
21297
|
+
|
21298
|
+
__exports__.makeSettledResult = makeSettledResult;function Enumerator(Constructor, input, abortOnReject, label) {
|
21299
|
+
this._instanceConstructor = Constructor;
|
21300
|
+
this.promise = new Constructor(noop, label);
|
21301
|
+
this._abortOnReject = abortOnReject;
|
21302
|
+
|
21303
|
+
if (this._validateInput(input)) {
|
21304
|
+
this._input = input;
|
21305
|
+
this.length = input.length;
|
21306
|
+
this._remaining = input.length;
|
21307
|
+
|
21308
|
+
this._init();
|
21309
|
+
|
21310
|
+
if (this.length === 0) {
|
21311
|
+
fulfill(this.promise, this._result);
|
21083
21312
|
} else {
|
21084
|
-
|
21313
|
+
this.length = this.length || 0;
|
21314
|
+
this._enumerate();
|
21315
|
+
if (this._remaining === 0) {
|
21316
|
+
fulfill(this.promise, this._result);
|
21317
|
+
}
|
21085
21318
|
}
|
21319
|
+
} else {
|
21320
|
+
reject(this.promise, this._validationError());
|
21321
|
+
}
|
21086
21322
|
}
|
21087
|
-
|
21088
|
-
|
21323
|
+
|
21324
|
+
Enumerator.prototype._validateInput = function(input) {
|
21325
|
+
return isArray(input);
|
21089
21326
|
};
|
21090
|
-
|
21091
|
-
|
21327
|
+
|
21328
|
+
Enumerator.prototype._validationError = function() {
|
21329
|
+
return new Error('Array Methods must be provided an Array');
|
21092
21330
|
};
|
21093
|
-
|
21094
|
-
|
21331
|
+
|
21332
|
+
Enumerator.prototype._init = function() {
|
21333
|
+
this._result = new Array(this.length);
|
21095
21334
|
};
|
21096
|
-
|
21097
|
-
|
21098
|
-
|
21099
|
-
|
21100
|
-
|
21101
|
-
|
21102
|
-
|
21103
|
-
|
21335
|
+
|
21336
|
+
__exports__["default"] = Enumerator;
|
21337
|
+
|
21338
|
+
Enumerator.prototype._enumerate = function() {
|
21339
|
+
var length = this.length;
|
21340
|
+
var promise = this.promise;
|
21341
|
+
var input = this._input;
|
21342
|
+
|
21343
|
+
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
21344
|
+
this._eachEntry(input[i], i);
|
21345
|
+
}
|
21104
21346
|
};
|
21105
|
-
|
21106
|
-
|
21107
|
-
|
21108
|
-
|
21109
|
-
|
21110
|
-
|
21111
|
-
|
21112
|
-
this._willSettleAt(c.resolve(entry), i);
|
21113
|
-
}
|
21347
|
+
|
21348
|
+
Enumerator.prototype._eachEntry = function(entry, i) {
|
21349
|
+
var c = this._instanceConstructor;
|
21350
|
+
if (isMaybeThenable(entry)) {
|
21351
|
+
if (entry.constructor === c && entry._state !== PENDING) {
|
21352
|
+
entry._onerror = null;
|
21353
|
+
this._settledAt(entry._state, i, entry._result);
|
21114
21354
|
} else {
|
21115
|
-
|
21116
|
-
this._result[i] = this._makeResult(FULFILLED, i, entry);
|
21355
|
+
this._willSettleAt(c.resolve(entry), i);
|
21117
21356
|
}
|
21357
|
+
} else {
|
21358
|
+
this._remaining--;
|
21359
|
+
this._result[i] = this._makeResult(FULFILLED, i, entry);
|
21360
|
+
}
|
21118
21361
|
};
|
21119
|
-
|
21120
|
-
|
21121
|
-
|
21122
|
-
|
21123
|
-
|
21124
|
-
|
21125
|
-
|
21126
|
-
|
21127
|
-
|
21128
|
-
}
|
21129
|
-
|
21130
|
-
fulfill(promise, this._result);
|
21362
|
+
|
21363
|
+
Enumerator.prototype._settledAt = function(state, i, value) {
|
21364
|
+
var promise = this.promise;
|
21365
|
+
|
21366
|
+
if (promise._state === PENDING) {
|
21367
|
+
this._remaining--;
|
21368
|
+
|
21369
|
+
if (this._abortOnReject && state === REJECTED) {
|
21370
|
+
reject(promise, value);
|
21371
|
+
} else {
|
21372
|
+
this._result[i] = this._makeResult(state, i, value);
|
21131
21373
|
}
|
21374
|
+
}
|
21375
|
+
|
21376
|
+
if (this._remaining === 0) {
|
21377
|
+
fulfill(promise, this._result);
|
21378
|
+
}
|
21132
21379
|
};
|
21133
|
-
|
21134
|
-
|
21380
|
+
|
21381
|
+
Enumerator.prototype._makeResult = function(state, i, value) {
|
21382
|
+
return value;
|
21135
21383
|
};
|
21136
|
-
|
21137
|
-
|
21138
|
-
|
21139
|
-
|
21140
|
-
|
21141
|
-
|
21142
|
-
|
21384
|
+
|
21385
|
+
Enumerator.prototype._willSettleAt = function(promise, i) {
|
21386
|
+
var enumerator = this;
|
21387
|
+
|
21388
|
+
subscribe(promise, undefined, function(value) {
|
21389
|
+
enumerator._settledAt(FULFILLED, i, value);
|
21390
|
+
}, function(reason) {
|
21391
|
+
enumerator._settledAt(REJECTED, i, reason);
|
21392
|
+
});
|
21143
21393
|
};
|
21144
|
-
});
|
21145
|
-
define(
|
21146
|
-
|
21394
|
+
});
|
21395
|
+
define("rsvp/events",
|
21396
|
+
["exports"],
|
21397
|
+
function(__exports__) {
|
21398
|
+
"use strict";
|
21147
21399
|
function indexOf(callbacks, callback) {
|
21148
|
-
|
21149
|
-
|
21150
|
-
|
21151
|
-
|
21152
|
-
|
21153
|
-
return -1;
|
21400
|
+
for (var i=0, l=callbacks.length; i<l; i++) {
|
21401
|
+
if (callbacks[i] === callback) { return i; }
|
21402
|
+
}
|
21403
|
+
|
21404
|
+
return -1;
|
21154
21405
|
}
|
21406
|
+
|
21155
21407
|
function callbacksFor(object) {
|
21156
|
-
|
21157
|
-
|
21158
|
-
|
21159
|
-
}
|
21160
|
-
|
21408
|
+
var callbacks = object._promiseCallbacks;
|
21409
|
+
|
21410
|
+
if (!callbacks) {
|
21411
|
+
callbacks = object._promiseCallbacks = {};
|
21412
|
+
}
|
21413
|
+
|
21414
|
+
return callbacks;
|
21161
21415
|
}
|
21416
|
+
|
21162
21417
|
/**
|
21163
21418
|
@class RSVP.EventTarget
|
21164
21419
|
*/
|
21165
|
-
__exports__[
|
21166
|
-
|
21167
|
-
|
21168
|
-
|
21169
|
-
|
21170
|
-
|
21171
|
-
|
21172
|
-
}
|
21173
|
-
|
21174
|
-
|
21175
|
-
|
21176
|
-
|
21177
|
-
|
21178
|
-
|
21179
|
-
|
21180
|
-
|
21181
|
-
|
21182
|
-
|
21183
|
-
|
21184
|
-
|
21185
|
-
|
21186
|
-
|
21187
|
-
|
21188
|
-
|
21189
|
-
|
21190
|
-
|
21191
|
-
|
21192
|
-
|
21193
|
-
|
21194
|
-
}
|
21195
|
-
|
21196
|
-
|
21197
|
-
|
21198
|
-
|
21199
|
-
|
21200
|
-
|
21201
|
-
|
21202
|
-
|
21203
|
-
|
21420
|
+
__exports__["default"] = {
|
21421
|
+
|
21422
|
+
/**
|
21423
|
+
`RSVP.EventTarget.mixin` extends an object with EventTarget methods. For
|
21424
|
+
Example:
|
21425
|
+
|
21426
|
+
```javascript
|
21427
|
+
var object = {};
|
21428
|
+
|
21429
|
+
RSVP.EventTarget.mixin(object);
|
21430
|
+
|
21431
|
+
object.on('finished', function(event) {
|
21432
|
+
// handle event
|
21433
|
+
});
|
21434
|
+
|
21435
|
+
object.trigger('finished', { detail: value });
|
21436
|
+
```
|
21437
|
+
|
21438
|
+
`EventTarget.mixin` also works with prototypes:
|
21439
|
+
|
21440
|
+
```javascript
|
21441
|
+
var Person = function() {};
|
21442
|
+
RSVP.EventTarget.mixin(Person.prototype);
|
21443
|
+
|
21444
|
+
var yehuda = new Person();
|
21445
|
+
var tom = new Person();
|
21446
|
+
|
21447
|
+
yehuda.on('poke', function(event) {
|
21448
|
+
console.log('Yehuda says OW');
|
21449
|
+
});
|
21450
|
+
|
21451
|
+
tom.on('poke', function(event) {
|
21452
|
+
console.log('Tom says OW');
|
21453
|
+
});
|
21454
|
+
|
21455
|
+
yehuda.trigger('poke');
|
21456
|
+
tom.trigger('poke');
|
21457
|
+
```
|
21458
|
+
|
21459
|
+
@method mixin
|
21460
|
+
@for RSVP.EventTarget
|
21461
|
+
@private
|
21462
|
+
@param {Object} object object to extend with EventTarget methods
|
21463
|
+
*/
|
21464
|
+
mixin: function(object) {
|
21465
|
+
object.on = this.on;
|
21466
|
+
object.off = this.off;
|
21467
|
+
object.trigger = this.trigger;
|
21468
|
+
object._promiseCallbacks = undefined;
|
21469
|
+
return object;
|
21470
|
+
},
|
21471
|
+
|
21472
|
+
/**
|
21473
|
+
Registers a callback to be executed when `eventName` is triggered
|
21474
|
+
|
21475
|
+
```javascript
|
21476
|
+
object.on('event', function(eventInfo){
|
21477
|
+
// handle the event
|
21478
|
+
});
|
21479
|
+
|
21480
|
+
object.trigger('event');
|
21481
|
+
```
|
21482
|
+
|
21483
|
+
@method on
|
21484
|
+
@for RSVP.EventTarget
|
21485
|
+
@private
|
21486
|
+
@param {String} eventName name of the event to listen for
|
21487
|
+
@param {Function} callback function to be called when the event is triggered.
|
21488
|
+
*/
|
21489
|
+
on: function(eventName, callback) {
|
21490
|
+
var allCallbacks = callbacksFor(this), callbacks;
|
21491
|
+
|
21492
|
+
callbacks = allCallbacks[eventName];
|
21493
|
+
|
21494
|
+
if (!callbacks) {
|
21495
|
+
callbacks = allCallbacks[eventName] = [];
|
21496
|
+
}
|
21497
|
+
|
21498
|
+
if (indexOf(callbacks, callback) === -1) {
|
21499
|
+
callbacks.push(callback);
|
21500
|
+
}
|
21501
|
+
},
|
21502
|
+
|
21503
|
+
/**
|
21504
|
+
You can use `off` to stop firing a particular callback for an event:
|
21505
|
+
|
21506
|
+
```javascript
|
21507
|
+
function doStuff() { // do stuff! }
|
21508
|
+
object.on('stuff', doStuff);
|
21509
|
+
|
21510
|
+
object.trigger('stuff'); // doStuff will be called
|
21511
|
+
|
21512
|
+
// Unregister ONLY the doStuff callback
|
21513
|
+
object.off('stuff', doStuff);
|
21514
|
+
object.trigger('stuff'); // doStuff will NOT be called
|
21515
|
+
```
|
21516
|
+
|
21517
|
+
If you don't pass a `callback` argument to `off`, ALL callbacks for the
|
21518
|
+
event will not be executed when the event fires. For example:
|
21519
|
+
|
21520
|
+
```javascript
|
21521
|
+
var callback1 = function(){};
|
21522
|
+
var callback2 = function(){};
|
21523
|
+
|
21524
|
+
object.on('stuff', callback1);
|
21525
|
+
object.on('stuff', callback2);
|
21526
|
+
|
21527
|
+
object.trigger('stuff'); // callback1 and callback2 will be executed.
|
21528
|
+
|
21529
|
+
object.off('stuff');
|
21530
|
+
object.trigger('stuff'); // callback1 and callback2 will not be executed!
|
21531
|
+
```
|
21532
|
+
|
21533
|
+
@method off
|
21534
|
+
@for RSVP.EventTarget
|
21535
|
+
@private
|
21536
|
+
@param {String} eventName event to stop listening to
|
21537
|
+
@param {Function} callback optional argument. If given, only the function
|
21538
|
+
given will be removed from the event's callback queue. If no `callback`
|
21539
|
+
argument is given, all callbacks will be removed from the event's callback
|
21540
|
+
queue.
|
21541
|
+
*/
|
21542
|
+
off: function(eventName, callback) {
|
21543
|
+
var allCallbacks = callbacksFor(this), callbacks, index;
|
21544
|
+
|
21545
|
+
if (!callback) {
|
21546
|
+
allCallbacks[eventName] = [];
|
21547
|
+
return;
|
21548
|
+
}
|
21549
|
+
|
21550
|
+
callbacks = allCallbacks[eventName];
|
21551
|
+
|
21552
|
+
index = indexOf(callbacks, callback);
|
21553
|
+
|
21554
|
+
if (index !== -1) { callbacks.splice(index, 1); }
|
21555
|
+
},
|
21556
|
+
|
21557
|
+
/**
|
21558
|
+
Use `trigger` to fire custom events. For example:
|
21559
|
+
|
21560
|
+
```javascript
|
21561
|
+
object.on('foo', function(){
|
21562
|
+
console.log('foo event happened!');
|
21563
|
+
});
|
21564
|
+
object.trigger('foo');
|
21565
|
+
// 'foo event happened!' logged to the console
|
21566
|
+
```
|
21567
|
+
|
21568
|
+
You can also pass a value as a second argument to `trigger` that will be
|
21569
|
+
passed as an argument to all event listeners for the event:
|
21570
|
+
|
21571
|
+
```javascript
|
21572
|
+
object.on('foo', function(value){
|
21573
|
+
console.log(value.name);
|
21574
|
+
});
|
21575
|
+
|
21576
|
+
object.trigger('foo', { name: 'bar' });
|
21577
|
+
// 'bar' logged to the console
|
21578
|
+
```
|
21579
|
+
|
21580
|
+
@method trigger
|
21581
|
+
@for RSVP.EventTarget
|
21582
|
+
@private
|
21583
|
+
@param {String} eventName name of the event to be triggered
|
21584
|
+
@param {Any} options optional value to be passed to any event handlers for
|
21585
|
+
the given `eventName`
|
21586
|
+
*/
|
21587
|
+
trigger: function(eventName, options) {
|
21588
|
+
var allCallbacks = callbacksFor(this), callbacks, callback;
|
21589
|
+
|
21590
|
+
if (callbacks = allCallbacks[eventName]) {
|
21591
|
+
// Don't cache the callbacks.length since it may grow
|
21592
|
+
for (var i=0; i<callbacks.length; i++) {
|
21593
|
+
callback = callbacks[i];
|
21594
|
+
|
21595
|
+
callback(options);
|
21596
|
+
}
|
21204
21597
|
}
|
21598
|
+
}
|
21205
21599
|
};
|
21206
|
-
});
|
21207
|
-
define(
|
21208
|
-
|
21209
|
-
|
21210
|
-
|
21211
|
-
|
21212
|
-
'use strict';
|
21213
|
-
var Promise = __dependency1__['default'];
|
21600
|
+
});
|
21601
|
+
define("rsvp/filter",
|
21602
|
+
["./promise","./utils","exports"],
|
21603
|
+
function(__dependency1__, __dependency2__, __exports__) {
|
21604
|
+
"use strict";
|
21605
|
+
var Promise = __dependency1__["default"];
|
21214
21606
|
var isFunction = __dependency2__.isFunction;
|
21215
|
-
|
21607
|
+
|
21216
21608
|
/**
|
21217
21609
|
`RSVP.filter` is similar to JavaScript's native `filter` method, except that it
|
21218
21610
|
waits for all promises to become fulfilled before running the `filterFn` on
|
@@ -21245,8 +21637,8 @@ define('rsvp/filter', [
|
|
21245
21637
|
|
21246
21638
|
```javascript
|
21247
21639
|
var promise1 = RSVP.resolve(1);
|
21248
|
-
var promise2 = RSVP.reject(new Error(
|
21249
|
-
var promise3 = RSVP.reject(new Error(
|
21640
|
+
var promise2 = RSVP.reject(new Error('2'));
|
21641
|
+
var promise3 = RSVP.reject(new Error('3'));
|
21250
21642
|
var promises = [ promise1, promise2, promise3 ];
|
21251
21643
|
|
21252
21644
|
var filterFn = function(item){
|
@@ -21256,7 +21648,7 @@ define('rsvp/filter', [
|
|
21256
21648
|
RSVP.filter(promises, filterFn).then(function(array){
|
21257
21649
|
// Code here never runs because there are rejected promises!
|
21258
21650
|
}, function(reason) {
|
21259
|
-
// reason.message ===
|
21651
|
+
// reason.message === '2'
|
21260
21652
|
});
|
21261
21653
|
```
|
21262
21654
|
|
@@ -21298,53 +21690,59 @@ define('rsvp/filter', [
|
|
21298
21690
|
tooling.
|
21299
21691
|
@return {Promise}
|
21300
21692
|
*/
|
21301
|
-
__exports__[
|
21302
|
-
|
21303
|
-
|
21304
|
-
|
21305
|
-
|
21306
|
-
|
21307
|
-
|
21308
|
-
|
21309
|
-
|
21693
|
+
__exports__["default"] = function filter(promises, filterFn, label) {
|
21694
|
+
return Promise.all(promises, label).then(function(values) {
|
21695
|
+
if (!isFunction(filterFn)) {
|
21696
|
+
throw new TypeError("You must pass a function as filter's second argument.");
|
21697
|
+
}
|
21698
|
+
|
21699
|
+
var length = values.length;
|
21700
|
+
var filtered = new Array(length);
|
21701
|
+
|
21702
|
+
for (var i = 0; i < length; i++) {
|
21703
|
+
filtered[i] = filterFn(values[i]);
|
21704
|
+
}
|
21705
|
+
|
21706
|
+
return Promise.all(filtered, label).then(function(filtered) {
|
21707
|
+
var results = new Array(length);
|
21708
|
+
var newLength = 0;
|
21709
|
+
|
21710
|
+
for (var i = 0; i < length; i++) {
|
21711
|
+
if (filtered[i]) {
|
21712
|
+
results[newLength] = values[i];
|
21713
|
+
newLength++;
|
21310
21714
|
}
|
21311
|
-
|
21312
|
-
|
21313
|
-
|
21314
|
-
|
21315
|
-
|
21316
|
-
results[newLength] = values[i$2];
|
21317
|
-
newLength++;
|
21318
|
-
}
|
21319
|
-
}
|
21320
|
-
results.length = newLength;
|
21321
|
-
return results;
|
21322
|
-
});
|
21715
|
+
}
|
21716
|
+
|
21717
|
+
results.length = newLength;
|
21718
|
+
|
21719
|
+
return results;
|
21323
21720
|
});
|
21324
|
-
|
21325
|
-
}
|
21326
|
-
|
21327
|
-
|
21328
|
-
|
21329
|
-
|
21330
|
-
|
21331
|
-
|
21332
|
-
], function (__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
|
21333
|
-
'use strict';
|
21334
|
-
var Promise = __dependency1__['default'];
|
21721
|
+
});
|
21722
|
+
}
|
21723
|
+
});
|
21724
|
+
define("rsvp/hash-settled",
|
21725
|
+
["./promise","./enumerator","./promise-hash","./utils","exports"],
|
21726
|
+
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __exports__) {
|
21727
|
+
"use strict";
|
21728
|
+
var Promise = __dependency1__["default"];
|
21335
21729
|
var makeSettledResult = __dependency2__.makeSettledResult;
|
21336
|
-
var PromiseHash = __dependency3__[
|
21337
|
-
var Enumerator = __dependency2__[
|
21730
|
+
var PromiseHash = __dependency3__["default"];
|
21731
|
+
var Enumerator = __dependency2__["default"];
|
21338
21732
|
var o_create = __dependency4__.o_create;
|
21733
|
+
|
21339
21734
|
function HashSettled(Constructor, object, label) {
|
21340
|
-
|
21735
|
+
this._superConstructor(Constructor, object, false, label);
|
21341
21736
|
}
|
21737
|
+
|
21342
21738
|
HashSettled.prototype = o_create(PromiseHash.prototype);
|
21343
21739
|
HashSettled.prototype._superConstructor = Enumerator;
|
21344
21740
|
HashSettled.prototype._makeResult = makeSettledResult;
|
21345
|
-
|
21346
|
-
|
21741
|
+
|
21742
|
+
HashSettled.prototype._validationError = function() {
|
21743
|
+
return new Error('hashSettled must be called with an object');
|
21347
21744
|
};
|
21745
|
+
|
21348
21746
|
/**
|
21349
21747
|
`RSVP.hashSettled` is similar to `RSVP.allSettled`, but takes an object
|
21350
21748
|
instead of an array for its `promises` argument.
|
@@ -21393,7 +21791,7 @@ define('rsvp/hash-settled', [
|
|
21393
21791
|
var promises = {
|
21394
21792
|
myPromise: RSVP.Promise.resolve(1),
|
21395
21793
|
rejectedPromise: RSVP.Promise.reject(new Error('rejection')),
|
21396
|
-
anotherRejectedPromise: RSVP.Promise.reject(new Error('more rejection'))
|
21794
|
+
anotherRejectedPromise: RSVP.Promise.reject(new Error('more rejection')),
|
21397
21795
|
};
|
21398
21796
|
|
21399
21797
|
RSVP.hashSettled(promises).then(function(hash){
|
@@ -21446,20 +21844,17 @@ define('rsvp/hash-settled', [
|
|
21446
21844
|
have been settled.
|
21447
21845
|
@static
|
21448
21846
|
*/
|
21449
|
-
__exports__[
|
21450
|
-
|
21451
|
-
}
|
21452
|
-
});
|
21453
|
-
define(
|
21454
|
-
|
21455
|
-
|
21456
|
-
|
21457
|
-
|
21458
|
-
|
21459
|
-
|
21460
|
-
var Promise = __dependency1__['default'];
|
21461
|
-
var PromiseHash = __dependency2__['default'];
|
21462
|
-
var ABORT_ON_REJECTION = __dependency3__.ABORT_ON_REJECTION;
|
21847
|
+
__exports__["default"] = function hashSettled(object, label) {
|
21848
|
+
return new HashSettled(Promise, object, label).promise;
|
21849
|
+
}
|
21850
|
+
});
|
21851
|
+
define("rsvp/hash",
|
21852
|
+
["./promise","./promise-hash","exports"],
|
21853
|
+
function(__dependency1__, __dependency2__, __exports__) {
|
21854
|
+
"use strict";
|
21855
|
+
var Promise = __dependency1__["default"];
|
21856
|
+
var PromiseHash = __dependency2__["default"];
|
21857
|
+
|
21463
21858
|
/**
|
21464
21859
|
`RSVP.hash` is similar to `RSVP.all`, but takes an object instead of an array
|
21465
21860
|
for its `promises` argument.
|
@@ -21499,14 +21894,14 @@ define('rsvp/hash', [
|
|
21499
21894
|
```javascript
|
21500
21895
|
var promises = {
|
21501
21896
|
myPromise: RSVP.resolve(1),
|
21502
|
-
rejectedPromise: RSVP.reject(new Error(
|
21503
|
-
anotherRejectedPromise: RSVP.reject(new Error(
|
21897
|
+
rejectedPromise: RSVP.reject(new Error('rejectedPromise')),
|
21898
|
+
anotherRejectedPromise: RSVP.reject(new Error('anotherRejectedPromise')),
|
21504
21899
|
};
|
21505
21900
|
|
21506
21901
|
RSVP.hash(promises).then(function(hash){
|
21507
21902
|
// Code here never runs because there are rejected promises!
|
21508
21903
|
}, function(reason) {
|
21509
|
-
// reason.message ===
|
21904
|
+
// reason.message === 'rejectedPromise'
|
21510
21905
|
});
|
21511
21906
|
```
|
21512
21907
|
|
@@ -21518,11 +21913,11 @@ define('rsvp/hash', [
|
|
21518
21913
|
|
21519
21914
|
```javascript
|
21520
21915
|
function MyConstructor(){
|
21521
|
-
this.example = RSVP.resolve(
|
21916
|
+
this.example = RSVP.resolve('Example');
|
21522
21917
|
}
|
21523
21918
|
|
21524
21919
|
MyConstructor.prototype = {
|
21525
|
-
protoProperty: RSVP.resolve(
|
21920
|
+
protoProperty: RSVP.resolve('Proto Property')
|
21526
21921
|
};
|
21527
21922
|
|
21528
21923
|
var myObject = new MyConstructor();
|
@@ -21531,7 +21926,7 @@ define('rsvp/hash', [
|
|
21531
21926
|
// protoProperty will not be present, instead you will just have an
|
21532
21927
|
// object that looks like:
|
21533
21928
|
// {
|
21534
|
-
// example:
|
21929
|
+
// example: 'Example'
|
21535
21930
|
// }
|
21536
21931
|
//
|
21537
21932
|
// hash.hasOwnProperty('protoProperty'); // false
|
@@ -21548,52 +21943,50 @@ define('rsvp/hash', [
|
|
21548
21943
|
@return {Promise} promise that is fulfilled when all properties of `promises`
|
21549
21944
|
have been fulfilled, or rejected if any of them become rejected.
|
21550
21945
|
*/
|
21551
|
-
__exports__[
|
21552
|
-
|
21553
|
-
}
|
21554
|
-
});
|
21555
|
-
define(
|
21556
|
-
|
21557
|
-
|
21558
|
-
|
21559
|
-
], function (__dependency1__, __dependency2__, __exports__) {
|
21560
|
-
'use strict';
|
21946
|
+
__exports__["default"] = function hash(object, label) {
|
21947
|
+
return new PromiseHash(Promise, object, label).promise;
|
21948
|
+
}
|
21949
|
+
});
|
21950
|
+
define("rsvp/instrument",
|
21951
|
+
["./config","./utils","exports"],
|
21952
|
+
function(__dependency1__, __dependency2__, __exports__) {
|
21953
|
+
"use strict";
|
21561
21954
|
var config = __dependency1__.config;
|
21562
21955
|
var now = __dependency2__.now;
|
21956
|
+
|
21563
21957
|
var queue = [];
|
21564
|
-
|
21565
|
-
|
21566
|
-
|
21567
|
-
|
21568
|
-
|
21569
|
-
|
21570
|
-
|
21571
|
-
|
21572
|
-
|
21573
|
-
|
21574
|
-
|
21575
|
-
|
21576
|
-
|
21577
|
-
|
21578
|
-
|
21579
|
-
|
21580
|
-
|
21581
|
-
|
21582
|
-
|
21583
|
-
|
21958
|
+
|
21959
|
+
__exports__["default"] = function instrument(eventName, promise, child) {
|
21960
|
+
if (1 === queue.push({
|
21961
|
+
name: eventName,
|
21962
|
+
payload: {
|
21963
|
+
guid: promise._guidKey + promise._id,
|
21964
|
+
eventName: eventName,
|
21965
|
+
detail: promise._result,
|
21966
|
+
childGuid: child && promise._guidKey + child._id,
|
21967
|
+
label: promise._label,
|
21968
|
+
timeStamp: now(),
|
21969
|
+
stack: new Error(promise._label).stack
|
21970
|
+
}})) {
|
21971
|
+
|
21972
|
+
setTimeout(function() {
|
21973
|
+
var entry;
|
21974
|
+
for (var i = 0; i < queue.length; i++) {
|
21975
|
+
entry = queue[i];
|
21976
|
+
config.trigger(entry.name, entry.payload);
|
21977
|
+
}
|
21978
|
+
queue.length = 0;
|
21584
21979
|
}, 50);
|
21585
|
-
|
21586
|
-
|
21587
|
-
});
|
21588
|
-
define(
|
21589
|
-
|
21590
|
-
|
21591
|
-
|
21592
|
-
|
21593
|
-
'use strict';
|
21594
|
-
var Promise = __dependency1__['default'];
|
21595
|
-
var isArray = __dependency2__.isArray;
|
21980
|
+
}
|
21981
|
+
}
|
21982
|
+
});
|
21983
|
+
define("rsvp/map",
|
21984
|
+
["./promise","./utils","exports"],
|
21985
|
+
function(__dependency1__, __dependency2__, __exports__) {
|
21986
|
+
"use strict";
|
21987
|
+
var Promise = __dependency1__["default"];
|
21596
21988
|
var isFunction = __dependency2__.isFunction;
|
21989
|
+
|
21597
21990
|
/**
|
21598
21991
|
`RSVP.map` is similar to JavaScript's native `map` method, except that it
|
21599
21992
|
waits for all promises to become fulfilled before running the `mapFn` on
|
@@ -21625,8 +22018,8 @@ define('rsvp/map', [
|
|
21625
22018
|
|
21626
22019
|
```javascript
|
21627
22020
|
var promise1 = RSVP.resolve(1);
|
21628
|
-
var promise2 = RSVP.reject(new Error(
|
21629
|
-
var promise3 = RSVP.reject(new Error(
|
22021
|
+
var promise2 = RSVP.reject(new Error('2'));
|
22022
|
+
var promise3 = RSVP.reject(new Error('3'));
|
21630
22023
|
var promises = [ promise1, promise2, promise3 ];
|
21631
22024
|
|
21632
22025
|
var mapFn = function(item){
|
@@ -21636,7 +22029,7 @@ define('rsvp/map', [
|
|
21636
22029
|
RSVP.map(promises, mapFn).then(function(array){
|
21637
22030
|
// Code here never runs because there are rejected promises!
|
21638
22031
|
}, function(reason) {
|
21639
|
-
// reason.message ===
|
22032
|
+
// reason.message === '2'
|
21640
22033
|
});
|
21641
22034
|
```
|
21642
22035
|
|
@@ -21672,31 +22065,99 @@ define('rsvp/map', [
|
|
21672
22065
|
The promise will be rejected if any of the given `promises` become rejected.
|
21673
22066
|
@static
|
21674
22067
|
*/
|
21675
|
-
__exports__[
|
21676
|
-
|
21677
|
-
|
21678
|
-
|
21679
|
-
|
21680
|
-
|
21681
|
-
|
21682
|
-
|
21683
|
-
|
21684
|
-
|
21685
|
-
|
21686
|
-
}
|
21687
|
-
|
21688
|
-
|
21689
|
-
|
21690
|
-
|
21691
|
-
|
21692
|
-
|
21693
|
-
|
21694
|
-
|
21695
|
-
|
21696
|
-
var Promise = __dependency1__[
|
21697
|
-
var
|
22068
|
+
__exports__["default"] = function map(promises, mapFn, label) {
|
22069
|
+
return Promise.all(promises, label).then(function(values) {
|
22070
|
+
if (!isFunction(mapFn)) {
|
22071
|
+
throw new TypeError("You must pass a function as map's second argument.");
|
22072
|
+
}
|
22073
|
+
|
22074
|
+
var length = values.length;
|
22075
|
+
var results = new Array(length);
|
22076
|
+
|
22077
|
+
for (var i = 0; i < length; i++) {
|
22078
|
+
results[i] = mapFn(values[i]);
|
22079
|
+
}
|
22080
|
+
|
22081
|
+
return Promise.all(results, label);
|
22082
|
+
});
|
22083
|
+
}
|
22084
|
+
});
|
22085
|
+
define("rsvp/node",
|
22086
|
+
["./promise","./-internal","./utils","exports"],
|
22087
|
+
function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
|
22088
|
+
"use strict";
|
22089
|
+
var Promise = __dependency1__["default"];
|
22090
|
+
var noop = __dependency2__.noop;
|
22091
|
+
var resolve = __dependency2__.resolve;
|
22092
|
+
var reject = __dependency2__.reject;
|
22093
|
+
var isArray = __dependency3__.isArray;
|
22094
|
+
|
22095
|
+
function Result() {
|
22096
|
+
this.value = undefined;
|
22097
|
+
}
|
22098
|
+
|
22099
|
+
var ERROR = new Result();
|
22100
|
+
var GET_THEN_ERROR = new Result();
|
22101
|
+
|
22102
|
+
function getThen(obj) {
|
22103
|
+
try {
|
22104
|
+
return obj.then;
|
22105
|
+
} catch(error) {
|
22106
|
+
ERROR.value= error;
|
22107
|
+
return ERROR;
|
22108
|
+
}
|
22109
|
+
}
|
22110
|
+
|
22111
|
+
|
22112
|
+
function tryApply(f, s, a) {
|
22113
|
+
try {
|
22114
|
+
f.apply(s, a);
|
22115
|
+
} catch(error) {
|
22116
|
+
ERROR.value = error;
|
22117
|
+
return ERROR;
|
22118
|
+
}
|
22119
|
+
}
|
22120
|
+
|
22121
|
+
function makeObject(_, argumentNames) {
|
22122
|
+
var obj = {};
|
22123
|
+
var name;
|
22124
|
+
var i;
|
22125
|
+
var length = _.length;
|
22126
|
+
var args = new Array(length);
|
22127
|
+
|
22128
|
+
for (var x = 0; x < length; x++) {
|
22129
|
+
args[x] = _[x];
|
22130
|
+
}
|
22131
|
+
|
22132
|
+
for (i = 0; i < argumentNames.length; i++) {
|
22133
|
+
name = argumentNames[i];
|
22134
|
+
obj[name] = args[i + 1];
|
22135
|
+
}
|
22136
|
+
|
22137
|
+
return obj;
|
22138
|
+
}
|
22139
|
+
|
22140
|
+
function arrayResult(_) {
|
22141
|
+
var length = _.length;
|
22142
|
+
var args = new Array(length - 1);
|
22143
|
+
|
22144
|
+
for (var i = 1; i < length; i++) {
|
22145
|
+
args[i - 1] = _[i];
|
22146
|
+
}
|
22147
|
+
|
22148
|
+
return args;
|
22149
|
+
}
|
22150
|
+
|
22151
|
+
function wrapThenable(then, promise) {
|
22152
|
+
return {
|
22153
|
+
then: function(onFulFillment, onRejection) {
|
22154
|
+
return then.call(promise, onFulFillment, onRejection);
|
22155
|
+
}
|
22156
|
+
};
|
22157
|
+
}
|
22158
|
+
|
21698
22159
|
/**
|
21699
|
-
`RSVP.denodeify` takes a
|
22160
|
+
`RSVP.denodeify` takes a 'node-style' function and returns a function that
|
21700
22161
|
will return an `RSVP.Promise`. You can use `denodeify` in Node.js or the
|
21701
22162
|
browser when you'd prefer to use promises over using callbacks. For example,
|
21702
22163
|
`denodeify` transforms the following:
|
@@ -21809,10 +22270,10 @@ define('rsvp/node', [
|
|
21809
22270
|
@method denodeify
|
21810
22271
|
@static
|
21811
22272
|
@for RSVP
|
21812
|
-
@param {Function} nodeFunc a
|
22273
|
+
@param {Function} nodeFunc a 'node-style' function that takes a callback as
|
21813
22274
|
its last argument. The callback expects an error to be passed as its first
|
21814
22275
|
argument (if an error occurred, otherwise null), and the value from the
|
21815
|
-
operation as its second argument (
|
22276
|
+
operation as its second argument ('function(err, value){ }').
|
21816
22277
|
@param {Boolean|Array} argumentNames An optional paramter that if set
|
21817
22278
|
to `true` causes the promise to fulfill with the callback's success arguments
|
21818
22279
|
as an array. This is useful if the node function has multiple success
|
@@ -21823,153 +22284,173 @@ define('rsvp/node', [
|
|
21823
22284
|
`RSVP.Promise`
|
21824
22285
|
@static
|
21825
22286
|
*/
|
21826
|
-
__exports__[
|
21827
|
-
|
21828
|
-
var
|
21829
|
-
|
21830
|
-
|
21831
|
-
|
21832
|
-
|
21833
|
-
|
21834
|
-
|
21835
|
-
|
21836
|
-
|
21837
|
-
|
21838
|
-
|
21839
|
-
|
21840
|
-
|
21841
|
-
|
21842
|
-
|
22287
|
+
__exports__["default"] = function denodeify(nodeFunc, options) {
|
22288
|
+
var fn = function() {
|
22289
|
+
var self = this;
|
22290
|
+
var l = arguments.length;
|
22291
|
+
var args = new Array(l + 1);
|
22292
|
+
var arg;
|
22293
|
+
var promiseInput = false;
|
22294
|
+
|
22295
|
+
for (var i = 0; i < l; ++i) {
|
22296
|
+
arg = arguments[i];
|
22297
|
+
|
22298
|
+
if (!promiseInput) {
|
22299
|
+
// TODO: clean this up
|
22300
|
+
promiseInput = needsPromiseInput(arg);
|
22301
|
+
if (promiseInput === GET_THEN_ERROR) {
|
22302
|
+
var p = new Promise(noop);
|
22303
|
+
reject(p, GET_THEN_ERROR.value);
|
22304
|
+
return p;
|
22305
|
+
} else if (promiseInput && promiseInput !== true) {
|
22306
|
+
arg = wrapThenable(promiseInput, arg);
|
21843
22307
|
}
|
21844
|
-
|
21845
|
-
|
21846
|
-
|
21847
|
-
|
21848
|
-
|
21849
|
-
|
21850
|
-
|
21851
|
-
|
21852
|
-
|
21853
|
-
|
21854
|
-
|
21855
|
-
|
21856
|
-
|
21857
|
-
|
21858
|
-
|
21859
|
-
|
21860
|
-
|
21861
|
-
|
21862
|
-
|
21863
|
-
|
21864
|
-
|
21865
|
-
|
21866
|
-
|
21867
|
-
name = argumentNames[i$3];
|
21868
|
-
obj[name] = successArguments[i$3];
|
21869
|
-
}
|
21870
|
-
resolve(obj);
|
21871
|
-
} else {
|
21872
|
-
resolve(value);
|
21873
|
-
}
|
21874
|
-
}
|
21875
|
-
nodeArgs$2.push(callback);
|
21876
|
-
nodeFunc.apply(thisArg, nodeArgs$2);
|
21877
|
-
}
|
21878
|
-
});
|
22308
|
+
}
|
22309
|
+
args[i] = arg;
|
22310
|
+
}
|
22311
|
+
|
22312
|
+
var promise = new Promise(noop);
|
22313
|
+
|
22314
|
+
args[l] = function(err, val) {
|
22315
|
+
if (err)
|
22316
|
+
reject(promise, err);
|
22317
|
+
else if (options === undefined)
|
22318
|
+
resolve(promise, val);
|
22319
|
+
else if (options === true)
|
22320
|
+
resolve(promise, arrayResult(arguments));
|
22321
|
+
else if (isArray(options))
|
22322
|
+
resolve(promise, makeObject(arguments, options));
|
22323
|
+
else
|
22324
|
+
resolve(promise, val);
|
22325
|
+
};
|
22326
|
+
|
22327
|
+
if (promiseInput) {
|
22328
|
+
return handlePromiseInput(promise, args, nodeFunc, self);
|
22329
|
+
} else {
|
22330
|
+
return handleValueInput(promise, args, nodeFunc, self);
|
21879
22331
|
}
|
21880
|
-
|
21881
|
-
|
21882
|
-
|
21883
|
-
|
21884
|
-
|
21885
|
-
|
21886
|
-
|
21887
|
-
|
21888
|
-
|
21889
|
-
|
21890
|
-
|
21891
|
-
|
22332
|
+
};
|
22333
|
+
|
22334
|
+
fn.__proto__ = nodeFunc;
|
22335
|
+
|
22336
|
+
return fn;
|
22337
|
+
}
|
22338
|
+
|
22339
|
+
function handleValueInput(promise, args, nodeFunc, self) {
|
22340
|
+
var result = tryApply(nodeFunc, self, args);
|
22341
|
+
if (result === ERROR) {
|
22342
|
+
reject(promise, result.value);
|
22343
|
+
}
|
22344
|
+
return promise;
|
22345
|
+
}
|
22346
|
+
|
22347
|
+
function handlePromiseInput(promise, args, nodeFunc, self){
|
22348
|
+
return Promise.all(args).then(function(args){
|
22349
|
+
var result = tryApply(nodeFunc, self, args);
|
22350
|
+
if (result === ERROR) {
|
22351
|
+
reject(promise, result.value);
|
22352
|
+
}
|
22353
|
+
return promise;
|
22354
|
+
});
|
22355
|
+
}
|
22356
|
+
|
22357
|
+
function needsPromiseInput(arg) {
|
22358
|
+
if (arg && typeof arg === 'object') {
|
22359
|
+
if (arg.constructor === Promise) {
|
22360
|
+
return true;
|
22361
|
+
} else {
|
22362
|
+
return getThen(arg);
|
22363
|
+
}
|
22364
|
+
} else {
|
22365
|
+
return false;
|
22366
|
+
}
|
22367
|
+
}
|
22368
|
+
});
|
22369
|
+
define("rsvp/promise-hash",
|
22370
|
+
["./enumerator","./-internal","./utils","exports"],
|
22371
|
+
function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
|
22372
|
+
"use strict";
|
22373
|
+
var Enumerator = __dependency1__["default"];
|
21892
22374
|
var PENDING = __dependency2__.PENDING;
|
21893
|
-
var FULFILLED = __dependency2__.FULFILLED;
|
21894
22375
|
var o_create = __dependency3__.o_create;
|
22376
|
+
|
21895
22377
|
function PromiseHash(Constructor, object, label) {
|
21896
|
-
|
22378
|
+
this._superConstructor(Constructor, object, true, label);
|
21897
22379
|
}
|
21898
|
-
|
22380
|
+
|
22381
|
+
__exports__["default"] = PromiseHash;
|
22382
|
+
|
21899
22383
|
PromiseHash.prototype = o_create(Enumerator.prototype);
|
21900
22384
|
PromiseHash.prototype._superConstructor = Enumerator;
|
21901
|
-
PromiseHash.prototype._init = function
|
21902
|
-
|
22385
|
+
PromiseHash.prototype._init = function() {
|
22386
|
+
this._result = {};
|
21903
22387
|
};
|
21904
|
-
|
21905
|
-
|
22388
|
+
|
22389
|
+
PromiseHash.prototype._validateInput = function(input) {
|
22390
|
+
return input && typeof input === 'object';
|
21906
22391
|
};
|
21907
|
-
|
21908
|
-
|
22392
|
+
|
22393
|
+
PromiseHash.prototype._validationError = function() {
|
22394
|
+
return new Error('Promise.hash must be called with an object');
|
21909
22395
|
};
|
21910
|
-
|
21911
|
-
|
21912
|
-
|
21913
|
-
|
21914
|
-
|
21915
|
-
|
21916
|
-
|
21917
|
-
|
21918
|
-
|
21919
|
-
|
21920
|
-
|
21921
|
-
|
21922
|
-
var length = results.length;
|
21923
|
-
this._remaining = length;
|
21924
|
-
var result;
|
21925
|
-
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
21926
|
-
result = results[i];
|
21927
|
-
this._eachEntry(result.entry, result.position);
|
22396
|
+
|
22397
|
+
PromiseHash.prototype._enumerate = function() {
|
22398
|
+
var promise = this.promise;
|
22399
|
+
var input = this._input;
|
22400
|
+
var results = [];
|
22401
|
+
|
22402
|
+
for (var key in input) {
|
22403
|
+
if (promise._state === PENDING && input.hasOwnProperty(key)) {
|
22404
|
+
results.push({
|
22405
|
+
position: key,
|
22406
|
+
entry: input[key]
|
22407
|
+
});
|
21928
22408
|
}
|
22409
|
+
}
|
22410
|
+
|
22411
|
+
var length = results.length;
|
22412
|
+
this._remaining = length;
|
22413
|
+
var result;
|
22414
|
+
|
22415
|
+
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
22416
|
+
result = results[i];
|
22417
|
+
this._eachEntry(result.entry, result.position);
|
22418
|
+
}
|
21929
22419
|
};
|
21930
|
-
});
|
21931
|
-
define(
|
21932
|
-
|
21933
|
-
|
21934
|
-
|
21935
|
-
'./utils',
|
21936
|
-
'./-internal',
|
21937
|
-
'./promise/cast',
|
21938
|
-
'./promise/all',
|
21939
|
-
'./promise/race',
|
21940
|
-
'./promise/resolve',
|
21941
|
-
'./promise/reject',
|
21942
|
-
'exports'
|
21943
|
-
], function (__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __exports__) {
|
21944
|
-
'use strict';
|
22420
|
+
});
|
22421
|
+
define("rsvp/promise",
|
22422
|
+
["./config","./instrument","./utils","./-internal","./promise/all","./promise/race","./promise/resolve","./promise/reject","exports"],
|
22423
|
+
function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __exports__) {
|
22424
|
+
"use strict";
|
21945
22425
|
var config = __dependency1__.config;
|
21946
|
-
var
|
21947
|
-
|
21948
|
-
var
|
21949
|
-
var
|
21950
|
-
|
21951
|
-
var noop =
|
21952
|
-
var
|
21953
|
-
var
|
21954
|
-
var
|
21955
|
-
var
|
21956
|
-
var
|
21957
|
-
|
21958
|
-
var
|
21959
|
-
var
|
21960
|
-
var
|
21961
|
-
var
|
21962
|
-
|
21963
|
-
var Reject = __dependency10__['default'];
|
22426
|
+
var instrument = __dependency2__["default"];
|
22427
|
+
|
22428
|
+
var isFunction = __dependency3__.isFunction;
|
22429
|
+
var now = __dependency3__.now;
|
22430
|
+
|
22431
|
+
var noop = __dependency4__.noop;
|
22432
|
+
var subscribe = __dependency4__.subscribe;
|
22433
|
+
var initializePromise = __dependency4__.initializePromise;
|
22434
|
+
var invokeCallback = __dependency4__.invokeCallback;
|
22435
|
+
var FULFILLED = __dependency4__.FULFILLED;
|
22436
|
+
var REJECTED = __dependency4__.REJECTED;
|
22437
|
+
|
22438
|
+
var all = __dependency5__["default"];
|
22439
|
+
var race = __dependency6__["default"];
|
22440
|
+
var Resolve = __dependency7__["default"];
|
22441
|
+
var Reject = __dependency8__["default"];
|
22442
|
+
|
21964
22443
|
var guidKey = 'rsvp_' + now() + '-';
|
21965
22444
|
var counter = 0;
|
22445
|
+
|
21966
22446
|
function needsResolver() {
|
21967
|
-
|
22447
|
+
throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
|
21968
22448
|
}
|
22449
|
+
|
21969
22450
|
function needsNew() {
|
21970
|
-
|
22451
|
+
throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
|
21971
22452
|
}
|
21972
|
-
__exports__[
|
22453
|
+
__exports__["default"] = Promise;
|
21973
22454
|
/**
|
21974
22455
|
Promise objects represent the eventual result of an asynchronous operation. The
|
21975
22456
|
primary way of interacting with a promise is through its `then` method, which
|
@@ -22040,7 +22521,7 @@ define('rsvp/promise', [
|
|
22040
22521
|
if (this.status === 200) {
|
22041
22522
|
resolve(this.response);
|
22042
22523
|
} else {
|
22043
|
-
reject(new Error(
|
22524
|
+
reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
|
22044
22525
|
}
|
22045
22526
|
}
|
22046
22527
|
};
|
@@ -22075,79 +22556,363 @@ define('rsvp/promise', [
|
|
22075
22556
|
@constructor
|
22076
22557
|
*/
|
22077
22558
|
function Promise(resolver, label) {
|
22078
|
-
|
22079
|
-
|
22080
|
-
|
22081
|
-
|
22082
|
-
|
22559
|
+
this._id = counter++;
|
22560
|
+
this._label = label;
|
22561
|
+
this._state = undefined;
|
22562
|
+
this._result = undefined;
|
22563
|
+
this._subscribers = [];
|
22564
|
+
|
22565
|
+
if (config.instrument) {
|
22566
|
+
instrument('created', this);
|
22567
|
+
}
|
22568
|
+
|
22569
|
+
if (noop !== resolver) {
|
22570
|
+
if (!isFunction(resolver)) {
|
22571
|
+
needsResolver();
|
22083
22572
|
}
|
22084
|
-
|
22085
|
-
|
22086
|
-
|
22087
|
-
}
|
22088
|
-
if (!(this instanceof Promise)) {
|
22089
|
-
needsNew();
|
22090
|
-
}
|
22091
|
-
initializePromise(this, resolver);
|
22573
|
+
|
22574
|
+
if (!(this instanceof Promise)) {
|
22575
|
+
needsNew();
|
22092
22576
|
}
|
22577
|
+
|
22578
|
+
initializePromise(this, resolver);
|
22579
|
+
}
|
22093
22580
|
}
|
22094
|
-
|
22581
|
+
|
22582
|
+
Promise.cast = Resolve; // deprecated
|
22095
22583
|
Promise.all = all;
|
22096
22584
|
Promise.race = race;
|
22097
22585
|
Promise.resolve = Resolve;
|
22098
22586
|
Promise.reject = Reject;
|
22587
|
+
|
22099
22588
|
Promise.prototype = {
|
22100
|
-
|
22101
|
-
|
22102
|
-
|
22103
|
-
|
22104
|
-
|
22105
|
-
|
22106
|
-
|
22107
|
-
|
22108
|
-
|
22109
|
-
|
22110
|
-
|
22111
|
-
|
22112
|
-
|
22113
|
-
|
22114
|
-
|
22115
|
-
|
22116
|
-
|
22117
|
-
|
22118
|
-
|
22119
|
-
|
22120
|
-
|
22121
|
-
|
22122
|
-
|
22123
|
-
|
22124
|
-
|
22125
|
-
|
22126
|
-
|
22127
|
-
|
22128
|
-
|
22129
|
-
|
22130
|
-
|
22131
|
-
|
22132
|
-
|
22133
|
-
|
22134
|
-
|
22135
|
-
|
22136
|
-
|
22137
|
-
|
22138
|
-
|
22139
|
-
|
22140
|
-
|
22141
|
-
|
22589
|
+
constructor: Promise,
|
22590
|
+
|
22591
|
+
_guidKey: guidKey,
|
22592
|
+
|
22593
|
+
_onerror: function (reason) {
|
22594
|
+
config.trigger('error', reason);
|
22595
|
+
},
|
22596
|
+
|
22597
|
+
/**
|
22598
|
+
The primary way of interacting with a promise is through its `then` method,
|
22599
|
+
which registers callbacks to receive either a promise's eventual value or the
|
22600
|
+
reason why the promise cannot be fulfilled.
|
22601
|
+
|
22602
|
+
```js
|
22603
|
+
findUser().then(function(user){
|
22604
|
+
// user is available
|
22605
|
+
}, function(reason){
|
22606
|
+
// user is unavailable, and you are given the reason why
|
22607
|
+
});
|
22608
|
+
```
|
22609
|
+
|
22610
|
+
Chaining
|
22611
|
+
--------
|
22612
|
+
|
22613
|
+
The return value of `then` is itself a promise. This second, 'downstream'
|
22614
|
+
promise is resolved with the return value of the first promise's fulfillment
|
22615
|
+
or rejection handler, or rejected if the handler throws an exception.
|
22616
|
+
|
22617
|
+
```js
|
22618
|
+
findUser().then(function (user) {
|
22619
|
+
return user.name;
|
22620
|
+
}, function (reason) {
|
22621
|
+
return 'default name';
|
22622
|
+
}).then(function (userName) {
|
22623
|
+
// If `findUser` fulfilled, `userName` will be the user's name, otherwise it
|
22624
|
+
// will be `'default name'`
|
22625
|
+
});
|
22626
|
+
|
22627
|
+
findUser().then(function (user) {
|
22628
|
+
throw new Error('Found user, but still unhappy');
|
22629
|
+
}, function (reason) {
|
22630
|
+
throw new Error('`findUser` rejected and we're unhappy');
|
22631
|
+
}).then(function (value) {
|
22632
|
+
// never reached
|
22633
|
+
}, function (reason) {
|
22634
|
+
// if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
|
22635
|
+
// If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
|
22636
|
+
});
|
22637
|
+
```
|
22638
|
+
If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
|
22639
|
+
|
22640
|
+
```js
|
22641
|
+
findUser().then(function (user) {
|
22642
|
+
throw new PedagogicalException('Upstream error');
|
22643
|
+
}).then(function (value) {
|
22644
|
+
// never reached
|
22645
|
+
}).then(function (value) {
|
22646
|
+
// never reached
|
22647
|
+
}, function (reason) {
|
22648
|
+
// The `PedgagocialException` is propagated all the way down to here
|
22649
|
+
});
|
22650
|
+
```
|
22651
|
+
|
22652
|
+
Assimilation
|
22653
|
+
------------
|
22654
|
+
|
22655
|
+
Sometimes the value you want to propagate to a downstream promise can only be
|
22656
|
+
retrieved asynchronously. This can be achieved by returning a promise in the
|
22657
|
+
fulfillment or rejection handler. The downstream promise will then be pending
|
22658
|
+
until the returned promise is settled. This is called *assimilation*.
|
22659
|
+
|
22660
|
+
```js
|
22661
|
+
findUser().then(function (user) {
|
22662
|
+
return findCommentsByAuthor(user);
|
22663
|
+
}).then(function (comments) {
|
22664
|
+
// The user's comments are now available
|
22665
|
+
});
|
22666
|
+
```
|
22667
|
+
|
22668
|
+
If the assimliated promise rejects, then the downstream promise will also reject.
|
22669
|
+
|
22670
|
+
```js
|
22671
|
+
findUser().then(function (user) {
|
22672
|
+
return findCommentsByAuthor(user);
|
22673
|
+
}).then(function (comments) {
|
22674
|
+
// If `findCommentsByAuthor` fulfills, we'll have the value here
|
22675
|
+
}, function (reason) {
|
22676
|
+
// If `findCommentsByAuthor` rejects, we'll have the reason here
|
22677
|
+
});
|
22678
|
+
```
|
22679
|
+
|
22680
|
+
Simple Example
|
22681
|
+
--------------
|
22682
|
+
|
22683
|
+
Synchronous Example
|
22684
|
+
|
22685
|
+
```javascript
|
22686
|
+
var result;
|
22687
|
+
|
22688
|
+
try {
|
22689
|
+
result = findResult();
|
22690
|
+
// success
|
22691
|
+
} catch(reason) {
|
22692
|
+
// failure
|
22693
|
+
}
|
22694
|
+
```
|
22695
|
+
|
22696
|
+
Errback Example
|
22697
|
+
|
22698
|
+
```js
|
22699
|
+
findResult(function(result, err){
|
22700
|
+
if (err) {
|
22701
|
+
// failure
|
22702
|
+
} else {
|
22703
|
+
// success
|
22704
|
+
}
|
22705
|
+
});
|
22706
|
+
```
|
22707
|
+
|
22708
|
+
Promise Example;
|
22709
|
+
|
22710
|
+
```javascript
|
22711
|
+
findResult().then(function(result){
|
22712
|
+
// success
|
22713
|
+
}, function(reason){
|
22714
|
+
// failure
|
22715
|
+
});
|
22716
|
+
```
|
22717
|
+
|
22718
|
+
Advanced Example
|
22719
|
+
--------------
|
22720
|
+
|
22721
|
+
Synchronous Example
|
22722
|
+
|
22723
|
+
```javascript
|
22724
|
+
var author, books;
|
22725
|
+
|
22726
|
+
try {
|
22727
|
+
author = findAuthor();
|
22728
|
+
books = findBooksByAuthor(author);
|
22729
|
+
// success
|
22730
|
+
} catch(reason) {
|
22731
|
+
// failure
|
22732
|
+
}
|
22733
|
+
```
|
22734
|
+
|
22735
|
+
Errback Example
|
22736
|
+
|
22737
|
+
```js
|
22738
|
+
|
22739
|
+
function foundBooks(books) {
|
22740
|
+
|
22741
|
+
}
|
22742
|
+
|
22743
|
+
function failure(reason) {
|
22744
|
+
|
22745
|
+
}
|
22746
|
+
|
22747
|
+
findAuthor(function(author, err){
|
22748
|
+
if (err) {
|
22749
|
+
failure(err);
|
22750
|
+
// failure
|
22751
|
+
} else {
|
22752
|
+
try {
|
22753
|
+
findBoooksByAuthor(author, function(books, err) {
|
22754
|
+
if (err) {
|
22755
|
+
failure(err);
|
22756
|
+
} else {
|
22757
|
+
try {
|
22758
|
+
foundBooks(books);
|
22759
|
+
} catch(reason) {
|
22760
|
+
failure(reason);
|
22761
|
+
}
|
22762
|
+
}
|
22763
|
+
});
|
22764
|
+
} catch(error) {
|
22765
|
+
failure(err);
|
22766
|
+
}
|
22767
|
+
// success
|
22768
|
+
}
|
22769
|
+
});
|
22770
|
+
```
|
22771
|
+
|
22772
|
+
Promise Example;
|
22773
|
+
|
22774
|
+
```javascript
|
22775
|
+
findAuthor().
|
22776
|
+
then(findBooksByAuthor).
|
22777
|
+
then(function(books){
|
22778
|
+
// found books
|
22779
|
+
}).catch(function(reason){
|
22780
|
+
// something went wrong
|
22781
|
+
});
|
22782
|
+
```
|
22783
|
+
|
22784
|
+
@method then
|
22785
|
+
@param {Function} onFulfilled
|
22786
|
+
@param {Function} onRejected
|
22787
|
+
@param {String} label optional string for labeling the promise.
|
22788
|
+
Useful for tooling.
|
22789
|
+
@return {Promise}
|
22790
|
+
*/
|
22791
|
+
then: function(onFulfillment, onRejection, label) {
|
22792
|
+
var parent = this;
|
22793
|
+
var state = parent._state;
|
22794
|
+
|
22795
|
+
if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
|
22796
|
+
if (config.instrument) {
|
22797
|
+
instrument('chained', this, this);
|
22798
|
+
}
|
22799
|
+
return this;
|
22800
|
+
}
|
22801
|
+
|
22802
|
+
parent._onerror = null;
|
22803
|
+
|
22804
|
+
var child = new this.constructor(noop, label);
|
22805
|
+
var result = parent._result;
|
22806
|
+
|
22807
|
+
if (config.instrument) {
|
22808
|
+
instrument('chained', parent, child);
|
22809
|
+
}
|
22810
|
+
|
22811
|
+
if (state) {
|
22812
|
+
var callback = arguments[state - 1];
|
22813
|
+
config.async(function(){
|
22814
|
+
invokeCallback(state, child, callback, result);
|
22815
|
+
});
|
22816
|
+
} else {
|
22817
|
+
subscribe(parent, child, onFulfillment, onRejection);
|
22142
22818
|
}
|
22819
|
+
|
22820
|
+
return child;
|
22821
|
+
},
|
22822
|
+
|
22823
|
+
/**
|
22824
|
+
`catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
|
22825
|
+
as the catch block of a try/catch statement.
|
22826
|
+
|
22827
|
+
```js
|
22828
|
+
function findAuthor(){
|
22829
|
+
throw new Error('couldn't find that author');
|
22830
|
+
}
|
22831
|
+
|
22832
|
+
// synchronous
|
22833
|
+
try {
|
22834
|
+
findAuthor();
|
22835
|
+
} catch(reason) {
|
22836
|
+
// something went wrong
|
22837
|
+
}
|
22838
|
+
|
22839
|
+
// async with promises
|
22840
|
+
findAuthor().catch(function(reason){
|
22841
|
+
// something went wrong
|
22842
|
+
});
|
22843
|
+
```
|
22844
|
+
|
22845
|
+
@method catch
|
22846
|
+
@param {Function} onRejection
|
22847
|
+
@param {String} label optional string for labeling the promise.
|
22848
|
+
Useful for tooling.
|
22849
|
+
@return {Promise}
|
22850
|
+
*/
|
22851
|
+
'catch': function(onRejection, label) {
|
22852
|
+
return this.then(null, onRejection, label);
|
22853
|
+
},
|
22854
|
+
|
22855
|
+
/**
|
22856
|
+
`finally` will be invoked regardless of the promise's fate just as native
|
22857
|
+
try/catch/finally behaves
|
22858
|
+
|
22859
|
+
Synchronous example:
|
22860
|
+
|
22861
|
+
```js
|
22862
|
+
findAuthor() {
|
22863
|
+
if (Math.random() > 0.5) {
|
22864
|
+
throw new Error();
|
22865
|
+
}
|
22866
|
+
return new Author();
|
22867
|
+
}
|
22868
|
+
|
22869
|
+
try {
|
22870
|
+
return findAuthor(); // succeed or fail
|
22871
|
+
} catch(error) {
|
22872
|
+
return findOtherAuther();
|
22873
|
+
} finally {
|
22874
|
+
// always runs
|
22875
|
+
// doesn't affect the return value
|
22876
|
+
}
|
22877
|
+
```
|
22878
|
+
|
22879
|
+
Asynchronous example:
|
22880
|
+
|
22881
|
+
```js
|
22882
|
+
findAuthor().catch(function(reason){
|
22883
|
+
return findOtherAuther();
|
22884
|
+
}).finally(function(){
|
22885
|
+
// author was either found, or not
|
22886
|
+
});
|
22887
|
+
```
|
22888
|
+
|
22889
|
+
@method finally
|
22890
|
+
@param {Function} callback
|
22891
|
+
@param {String} label optional string for labeling the promise.
|
22892
|
+
Useful for tooling.
|
22893
|
+
@return {Promise}
|
22894
|
+
*/
|
22895
|
+
'finally': function(callback, label) {
|
22896
|
+
var constructor = this.constructor;
|
22897
|
+
|
22898
|
+
return this.then(function(value) {
|
22899
|
+
return constructor.resolve(callback()).then(function(){
|
22900
|
+
return value;
|
22901
|
+
});
|
22902
|
+
}, function(reason) {
|
22903
|
+
return constructor.resolve(callback()).then(function(){
|
22904
|
+
throw reason;
|
22905
|
+
});
|
22906
|
+
}, label);
|
22907
|
+
}
|
22143
22908
|
};
|
22144
|
-
});
|
22145
|
-
define(
|
22146
|
-
|
22147
|
-
|
22148
|
-
|
22149
|
-
|
22150
|
-
|
22909
|
+
});
|
22910
|
+
define("rsvp/promise/all",
|
22911
|
+
["../enumerator","exports"],
|
22912
|
+
function(__dependency1__, __exports__) {
|
22913
|
+
"use strict";
|
22914
|
+
var Enumerator = __dependency1__["default"];
|
22915
|
+
|
22151
22916
|
/**
|
22152
22917
|
`RSVP.Promise.all` accepts an array of promises, and returns a new promise which
|
22153
22918
|
is fulfilled with an array of fulfillment values for the passed promises, or
|
@@ -22195,100 +22960,22 @@ define('rsvp/promise/all', [
|
|
22195
22960
|
fulfilled, or rejected if any of them become rejected.
|
22196
22961
|
@static
|
22197
22962
|
*/
|
22198
|
-
__exports__[
|
22199
|
-
|
22200
|
-
}
|
22201
|
-
});
|
22202
|
-
define(
|
22203
|
-
|
22204
|
-
|
22205
|
-
|
22206
|
-
'use strict';
|
22207
|
-
var resolve = __dependency1__['default'];
|
22208
|
-
/**
|
22209
|
-
@deprecated
|
22210
|
-
|
22211
|
-
`RSVP.Promise.cast` coerces its argument to a promise, or returns the
|
22212
|
-
argument if it is already a promise which shares a constructor with the caster.
|
22213
|
-
|
22214
|
-
Example:
|
22215
|
-
|
22216
|
-
```javascript
|
22217
|
-
var promise = RSVP.Promise.resolve(1);
|
22218
|
-
var casted = RSVP.Promise.cast(promise);
|
22219
|
-
|
22220
|
-
console.log(promise === casted); // true
|
22221
|
-
```
|
22222
|
-
|
22223
|
-
In the case of a promise whose constructor does not match, it is assimilated.
|
22224
|
-
The resulting promise will fulfill or reject based on the outcome of the
|
22225
|
-
promise being casted.
|
22226
|
-
|
22227
|
-
Example:
|
22228
|
-
|
22229
|
-
```javascript
|
22230
|
-
var thennable = $.getJSON('/api/foo');
|
22231
|
-
var casted = RSVP.Promise.cast(thennable);
|
22232
|
-
|
22233
|
-
console.log(thennable === casted); // false
|
22234
|
-
console.log(casted instanceof RSVP.Promise) // true
|
22235
|
-
|
22236
|
-
casted.then(function(data) {
|
22237
|
-
// data is the value getJSON fulfills with
|
22238
|
-
});
|
22239
|
-
```
|
22240
|
-
|
22241
|
-
In the case of a non-promise, a promise which will fulfill with that value is
|
22242
|
-
returned.
|
22243
|
-
|
22244
|
-
Example:
|
22245
|
-
|
22246
|
-
```javascript
|
22247
|
-
var value = 1; // could be a number, boolean, string, undefined...
|
22248
|
-
var casted = RSVP.Promise.cast(value);
|
22249
|
-
|
22250
|
-
console.log(value === casted); // false
|
22251
|
-
console.log(casted instanceof RSVP.Promise) // true
|
22252
|
-
|
22253
|
-
casted.then(function(val) {
|
22254
|
-
val === value // => true
|
22255
|
-
});
|
22256
|
-
```
|
22257
|
-
|
22258
|
-
`RSVP.Promise.cast` is similar to `RSVP.Promise.resolve`, but `RSVP.Promise.cast` differs in the
|
22259
|
-
following ways:
|
22260
|
-
|
22261
|
-
* `RSVP.Promise.cast` serves as a memory-efficient way of getting a promise, when you
|
22262
|
-
have something that could either be a promise or a value. RSVP.resolve
|
22263
|
-
will have the same effect but will create a new promise wrapper if the
|
22264
|
-
argument is a promise.
|
22265
|
-
* `RSVP.Promise.cast` is a way of casting incoming thenables or promise subclasses to
|
22266
|
-
promises of the exact class specified, so that the resulting object's `then` is
|
22267
|
-
ensured to have the behavior of the constructor you are calling cast on (i.e., RSVP.Promise).
|
22268
|
-
|
22269
|
-
@method cast
|
22270
|
-
@static
|
22271
|
-
@param {Object} object to be casted
|
22272
|
-
@param {String} label optional string for labeling the promise.
|
22273
|
-
Useful for tooling.
|
22274
|
-
@return {Promise} promise
|
22275
|
-
*/
|
22276
|
-
__exports__['default'] = resolve;
|
22277
|
-
});
|
22278
|
-
define('rsvp/promise/race', [
|
22279
|
-
'../utils',
|
22280
|
-
'../-internal',
|
22281
|
-
'exports'
|
22282
|
-
], function (__dependency1__, __dependency2__, __exports__) {
|
22283
|
-
'use strict';
|
22963
|
+
__exports__["default"] = function all(entries, label) {
|
22964
|
+
return new Enumerator(this, entries, true /* abort on reject */, label).promise;
|
22965
|
+
}
|
22966
|
+
});
|
22967
|
+
define("rsvp/promise/race",
|
22968
|
+
["../utils","../-internal","exports"],
|
22969
|
+
function(__dependency1__, __dependency2__, __exports__) {
|
22970
|
+
"use strict";
|
22284
22971
|
var isArray = __dependency1__.isArray;
|
22285
|
-
|
22286
|
-
var isMaybeThenable = __dependency1__.isMaybeThenable;
|
22972
|
+
|
22287
22973
|
var noop = __dependency2__.noop;
|
22288
22974
|
var resolve = __dependency2__.resolve;
|
22289
22975
|
var reject = __dependency2__.reject;
|
22290
22976
|
var subscribe = __dependency2__.subscribe;
|
22291
22977
|
var PENDING = __dependency2__.PENDING;
|
22978
|
+
|
22292
22979
|
/**
|
22293
22980
|
`RSVP.Promise.race` returns a new promise which is settled in the same way as the
|
22294
22981
|
first passed promise to settle.
|
@@ -22298,18 +22985,18 @@ define('rsvp/promise/race', [
|
|
22298
22985
|
```javascript
|
22299
22986
|
var promise1 = new RSVP.Promise(function(resolve, reject){
|
22300
22987
|
setTimeout(function(){
|
22301
|
-
resolve(
|
22988
|
+
resolve('promise 1');
|
22302
22989
|
}, 200);
|
22303
22990
|
});
|
22304
22991
|
|
22305
22992
|
var promise2 = new RSVP.Promise(function(resolve, reject){
|
22306
22993
|
setTimeout(function(){
|
22307
|
-
resolve(
|
22994
|
+
resolve('promise 2');
|
22308
22995
|
}, 100);
|
22309
22996
|
});
|
22310
22997
|
|
22311
22998
|
RSVP.Promise.race([promise1, promise2]).then(function(result){
|
22312
|
-
// result ===
|
22999
|
+
// result === 'promise 2' because it was resolved before promise1
|
22313
23000
|
// was resolved.
|
22314
23001
|
});
|
22315
23002
|
```
|
@@ -22323,20 +23010,20 @@ define('rsvp/promise/race', [
|
|
22323
23010
|
```javascript
|
22324
23011
|
var promise1 = new RSVP.Promise(function(resolve, reject){
|
22325
23012
|
setTimeout(function(){
|
22326
|
-
resolve(
|
23013
|
+
resolve('promise 1');
|
22327
23014
|
}, 200);
|
22328
23015
|
});
|
22329
23016
|
|
22330
23017
|
var promise2 = new RSVP.Promise(function(resolve, reject){
|
22331
23018
|
setTimeout(function(){
|
22332
|
-
reject(new Error(
|
23019
|
+
reject(new Error('promise 2'));
|
22333
23020
|
}, 100);
|
22334
23021
|
});
|
22335
23022
|
|
22336
23023
|
RSVP.Promise.race([promise1, promise2]).then(function(result){
|
22337
23024
|
// Code here never runs
|
22338
23025
|
}, function(reason){
|
22339
|
-
// reason.message ===
|
23026
|
+
// reason.message === 'promise 2' because promise 2 became rejected before
|
22340
23027
|
// promise 1 became fulfilled
|
22341
23028
|
});
|
22342
23029
|
```
|
@@ -22355,34 +23042,41 @@ define('rsvp/promise/race', [
|
|
22355
23042
|
@return {Promise} a promise which settles in the same way as the first passed
|
22356
23043
|
promise to settle.
|
22357
23044
|
*/
|
22358
|
-
__exports__[
|
22359
|
-
|
22360
|
-
|
22361
|
-
|
22362
|
-
|
22363
|
-
|
22364
|
-
|
22365
|
-
|
22366
|
-
var length = entries.length;
|
22367
|
-
function onFulfillment(value) {
|
22368
|
-
resolve(promise, value);
|
22369
|
-
}
|
22370
|
-
function onRejection(reason) {
|
22371
|
-
reject(promise, reason);
|
22372
|
-
}
|
22373
|
-
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
22374
|
-
subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
|
22375
|
-
}
|
23045
|
+
__exports__["default"] = function race(entries, label) {
|
23046
|
+
/*jshint validthis:true */
|
23047
|
+
var Constructor = this;
|
23048
|
+
|
23049
|
+
var promise = new Constructor(noop, label);
|
23050
|
+
|
23051
|
+
if (!isArray(entries)) {
|
23052
|
+
reject(promise, new TypeError('You must pass an array to race.'));
|
22376
23053
|
return promise;
|
22377
|
-
|
22378
|
-
|
22379
|
-
|
22380
|
-
|
22381
|
-
|
22382
|
-
|
22383
|
-
|
23054
|
+
}
|
23055
|
+
|
23056
|
+
var length = entries.length;
|
23057
|
+
|
23058
|
+
function onFulfillment(value) {
|
23059
|
+
resolve(promise, value);
|
23060
|
+
}
|
23061
|
+
|
23062
|
+
function onRejection(reason) {
|
23063
|
+
reject(promise, reason);
|
23064
|
+
}
|
23065
|
+
|
23066
|
+
for (var i = 0; promise._state === PENDING && i < length; i++) {
|
23067
|
+
subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
|
23068
|
+
}
|
23069
|
+
|
23070
|
+
return promise;
|
23071
|
+
}
|
23072
|
+
});
|
23073
|
+
define("rsvp/promise/reject",
|
23074
|
+
["../-internal","exports"],
|
23075
|
+
function(__dependency1__, __exports__) {
|
23076
|
+
"use strict";
|
22384
23077
|
var noop = __dependency1__.noop;
|
22385
23078
|
var _reject = __dependency1__.reject;
|
23079
|
+
|
22386
23080
|
/**
|
22387
23081
|
`RSVP.Promise.reject` returns a promise rejected with the passed `reason`.
|
22388
23082
|
It is shorthand for the following:
|
@@ -22418,21 +23112,21 @@ define('rsvp/promise/reject', [
|
|
22418
23112
|
Useful for tooling.
|
22419
23113
|
@return {Promise} a promise rejected with the given `reason`.
|
22420
23114
|
*/
|
22421
|
-
__exports__[
|
22422
|
-
|
22423
|
-
|
22424
|
-
|
22425
|
-
|
22426
|
-
|
22427
|
-
}
|
22428
|
-
});
|
22429
|
-
define(
|
22430
|
-
|
22431
|
-
|
22432
|
-
|
22433
|
-
'use strict';
|
23115
|
+
__exports__["default"] = function reject(reason, label) {
|
23116
|
+
/*jshint validthis:true */
|
23117
|
+
var Constructor = this;
|
23118
|
+
var promise = new Constructor(noop, label);
|
23119
|
+
_reject(promise, reason);
|
23120
|
+
return promise;
|
23121
|
+
}
|
23122
|
+
});
|
23123
|
+
define("rsvp/promise/resolve",
|
23124
|
+
["../-internal","exports"],
|
23125
|
+
function(__dependency1__, __exports__) {
|
23126
|
+
"use strict";
|
22434
23127
|
var noop = __dependency1__.noop;
|
22435
23128
|
var _resolve = __dependency1__.resolve;
|
23129
|
+
|
22436
23130
|
/**
|
22437
23131
|
`RSVP.Promise.resolve` returns a promise that will become resolved with the
|
22438
23132
|
passed `value`. It is shorthand for the following:
|
@@ -22465,23 +23159,25 @@ define('rsvp/promise/resolve', [
|
|
22465
23159
|
@return {Promise} a promise that will become fulfilled with the given
|
22466
23160
|
`value`
|
22467
23161
|
*/
|
22468
|
-
__exports__[
|
22469
|
-
|
22470
|
-
|
22471
|
-
|
22472
|
-
|
22473
|
-
|
22474
|
-
|
22475
|
-
|
22476
|
-
|
22477
|
-
|
22478
|
-
|
22479
|
-
|
22480
|
-
|
22481
|
-
|
22482
|
-
],
|
22483
|
-
|
22484
|
-
|
23162
|
+
__exports__["default"] = function resolve(object, label) {
|
23163
|
+
/*jshint validthis:true */
|
23164
|
+
var Constructor = this;
|
23165
|
+
|
23166
|
+
if (object && typeof object === 'object' && object.constructor === Constructor) {
|
23167
|
+
return object;
|
23168
|
+
}
|
23169
|
+
|
23170
|
+
var promise = new Constructor(noop, label);
|
23171
|
+
_resolve(promise, object);
|
23172
|
+
return promise;
|
23173
|
+
}
|
23174
|
+
});
|
23175
|
+
define("rsvp/race",
|
23176
|
+
["./promise","exports"],
|
23177
|
+
function(__dependency1__, __exports__) {
|
23178
|
+
"use strict";
|
23179
|
+
var Promise = __dependency1__["default"];
|
23180
|
+
|
22485
23181
|
/**
|
22486
23182
|
This is a convenient alias for `RSVP.Promise.race`.
|
22487
23183
|
|
@@ -22492,16 +23188,16 @@ define('rsvp/race', [
|
|
22492
23188
|
@param {String} label An optional label. This is useful
|
22493
23189
|
for tooling.
|
22494
23190
|
*/
|
22495
|
-
__exports__[
|
22496
|
-
|
22497
|
-
}
|
22498
|
-
});
|
22499
|
-
define(
|
22500
|
-
|
22501
|
-
|
22502
|
-
|
22503
|
-
|
22504
|
-
|
23191
|
+
__exports__["default"] = function race(array, label) {
|
23192
|
+
return Promise.race(array, label);
|
23193
|
+
}
|
23194
|
+
});
|
23195
|
+
define("rsvp/reject",
|
23196
|
+
["./promise","exports"],
|
23197
|
+
function(__dependency1__, __exports__) {
|
23198
|
+
"use strict";
|
23199
|
+
var Promise = __dependency1__["default"];
|
23200
|
+
|
22505
23201
|
/**
|
22506
23202
|
This is a convenient alias for `RSVP.Promise.reject`.
|
22507
23203
|
|
@@ -22513,16 +23209,16 @@ define('rsvp/reject', [
|
|
22513
23209
|
Useful for tooling.
|
22514
23210
|
@return {Promise} a promise rejected with the given `reason`.
|
22515
23211
|
*/
|
22516
|
-
__exports__[
|
22517
|
-
|
22518
|
-
}
|
22519
|
-
});
|
22520
|
-
define(
|
22521
|
-
|
22522
|
-
|
22523
|
-
|
22524
|
-
|
22525
|
-
|
23212
|
+
__exports__["default"] = function reject(reason, label) {
|
23213
|
+
return Promise.reject(reason, label);
|
23214
|
+
}
|
23215
|
+
});
|
23216
|
+
define("rsvp/resolve",
|
23217
|
+
["./promise","exports"],
|
23218
|
+
function(__dependency1__, __exports__) {
|
23219
|
+
"use strict";
|
23220
|
+
var Promise = __dependency1__["default"];
|
23221
|
+
|
22526
23222
|
/**
|
22527
23223
|
This is a convenient alias for `RSVP.Promise.resolve`.
|
22528
23224
|
|
@@ -22535,12 +23231,14 @@ define('rsvp/resolve', [
|
|
22535
23231
|
@return {Promise} a promise that will become fulfilled with the given
|
22536
23232
|
`value`
|
22537
23233
|
*/
|
22538
|
-
__exports__[
|
22539
|
-
|
22540
|
-
}
|
22541
|
-
});
|
22542
|
-
define(
|
22543
|
-
|
23234
|
+
__exports__["default"] = function resolve(value, label) {
|
23235
|
+
return Promise.resolve(value, label);
|
23236
|
+
}
|
23237
|
+
});
|
23238
|
+
define("rsvp/rethrow",
|
23239
|
+
["exports"],
|
23240
|
+
function(__exports__) {
|
23241
|
+
"use strict";
|
22544
23242
|
/**
|
22545
23243
|
`RSVP.rethrow` will rethrow an error on the next turn of the JavaScript event
|
22546
23244
|
loop in order to aid debugging.
|
@@ -22581,129 +23279,58 @@ define('rsvp/rethrow', ['exports'], function (__exports__) {
|
|
22581
23279
|
@throws Error
|
22582
23280
|
@static
|
22583
23281
|
*/
|
22584
|
-
__exports__[
|
22585
|
-
|
22586
|
-
throw reason;
|
22587
|
-
});
|
23282
|
+
__exports__["default"] = function rethrow(reason) {
|
23283
|
+
setTimeout(function() {
|
22588
23284
|
throw reason;
|
22589
|
-
|
22590
|
-
|
22591
|
-
|
22592
|
-
|
23285
|
+
});
|
23286
|
+
throw reason;
|
23287
|
+
}
|
23288
|
+
});
|
23289
|
+
define("rsvp/utils",
|
23290
|
+
["exports"],
|
23291
|
+
function(__exports__) {
|
23292
|
+
"use strict";
|
22593
23293
|
function objectOrFunction(x) {
|
22594
|
-
|
23294
|
+
return typeof x === 'function' || (typeof x === 'object' && x !== null);
|
22595
23295
|
}
|
22596
|
-
|
22597
|
-
function isFunction(x) {
|
22598
|
-
|
23296
|
+
|
23297
|
+
__exports__.objectOrFunction = objectOrFunction;function isFunction(x) {
|
23298
|
+
return typeof x === 'function';
|
22599
23299
|
}
|
22600
|
-
|
22601
|
-
function isMaybeThenable(x) {
|
22602
|
-
|
23300
|
+
|
23301
|
+
__exports__.isFunction = isFunction;function isMaybeThenable(x) {
|
23302
|
+
return typeof x === 'object' && x !== null;
|
22603
23303
|
}
|
22604
|
-
|
22605
|
-
var _isArray;
|
23304
|
+
|
23305
|
+
__exports__.isMaybeThenable = isMaybeThenable;var _isArray;
|
22606
23306
|
if (!Array.isArray) {
|
22607
|
-
|
22608
|
-
|
22609
|
-
|
23307
|
+
_isArray = function (x) {
|
23308
|
+
return Object.prototype.toString.call(x) === '[object Array]';
|
23309
|
+
};
|
22610
23310
|
} else {
|
22611
|
-
|
23311
|
+
_isArray = Array.isArray;
|
22612
23312
|
}
|
23313
|
+
|
22613
23314
|
var isArray = _isArray;
|
22614
23315
|
__exports__.isArray = isArray;
|
22615
23316
|
// Date.now is not available in browsers < IE9
|
22616
23317
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
|
22617
|
-
var now = Date.now || function ()
|
22618
|
-
return new Date().getTime();
|
22619
|
-
};
|
23318
|
+
var now = Date.now || function() { return new Date().getTime(); };
|
22620
23319
|
__exports__.now = now;
|
22621
|
-
|
22622
|
-
var o = function () {
|
22623
|
-
};
|
22624
|
-
o.prototype = object;
|
22625
|
-
return o;
|
22626
|
-
};
|
22627
|
-
__exports__.o_create = o_create;
|
22628
|
-
});
|
22629
|
-
define('rsvp', [
|
22630
|
-
'./rsvp/promise',
|
22631
|
-
'./rsvp/events',
|
22632
|
-
'./rsvp/node',
|
22633
|
-
'./rsvp/all',
|
22634
|
-
'./rsvp/all-settled',
|
22635
|
-
'./rsvp/race',
|
22636
|
-
'./rsvp/hash',
|
22637
|
-
'./rsvp/hash-settled',
|
22638
|
-
'./rsvp/rethrow',
|
22639
|
-
'./rsvp/defer',
|
22640
|
-
'./rsvp/config',
|
22641
|
-
'./rsvp/map',
|
22642
|
-
'./rsvp/resolve',
|
22643
|
-
'./rsvp/reject',
|
22644
|
-
'./rsvp/filter',
|
22645
|
-
'./rsvp/asap',
|
22646
|
-
'exports'
|
22647
|
-
], function (__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __dependency14__, __dependency15__, __dependency16__, __exports__) {
|
22648
|
-
'use strict';
|
22649
|
-
var Promise = __dependency1__['default'];
|
22650
|
-
var EventTarget = __dependency2__['default'];
|
22651
|
-
var denodeify = __dependency3__['default'];
|
22652
|
-
var all = __dependency4__['default'];
|
22653
|
-
var allSettled = __dependency5__['default'];
|
22654
|
-
var race = __dependency6__['default'];
|
22655
|
-
var hash = __dependency7__['default'];
|
22656
|
-
var hashSettled = __dependency8__['default'];
|
22657
|
-
var rethrow = __dependency9__['default'];
|
22658
|
-
var defer = __dependency10__['default'];
|
22659
|
-
var config = __dependency11__.config;
|
22660
|
-
var configure = __dependency11__.configure;
|
22661
|
-
var map = __dependency12__['default'];
|
22662
|
-
var resolve = __dependency13__['default'];
|
22663
|
-
var reject = __dependency14__['default'];
|
22664
|
-
var filter = __dependency15__['default'];
|
22665
|
-
var asap = __dependency16__['default'];
|
22666
|
-
config.async = asap;
|
22667
|
-
// default async is asap;
|
22668
|
-
function async(callback, arg) {
|
22669
|
-
config.async(callback, arg);
|
22670
|
-
}
|
22671
|
-
function on() {
|
22672
|
-
config.on.apply(config, arguments);
|
22673
|
-
}
|
22674
|
-
function off() {
|
22675
|
-
config.off.apply(config, arguments);
|
22676
|
-
}
|
22677
|
-
// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
|
22678
|
-
if (typeof window !== 'undefined' && typeof window.__PROMISE_INSTRUMENTATION__ === 'object') {
|
22679
|
-
var callbacks = window.__PROMISE_INSTRUMENTATION__;
|
22680
|
-
configure('instrument', true);
|
22681
|
-
for (var eventName in callbacks) {
|
22682
|
-
if (callbacks.hasOwnProperty(eventName)) {
|
22683
|
-
on(eventName, callbacks[eventName]);
|
22684
|
-
}
|
22685
|
-
}
|
22686
|
-
}
|
22687
|
-
__exports__.Promise = Promise;
|
22688
|
-
__exports__.EventTarget = EventTarget;
|
22689
|
-
__exports__.all = all;
|
22690
|
-
__exports__.allSettled = allSettled;
|
22691
|
-
__exports__.race = race;
|
22692
|
-
__exports__.hash = hash;
|
22693
|
-
__exports__.hashSettled = hashSettled;
|
22694
|
-
__exports__.rethrow = rethrow;
|
22695
|
-
__exports__.defer = defer;
|
22696
|
-
__exports__.denodeify = denodeify;
|
22697
|
-
__exports__.configure = configure;
|
22698
|
-
__exports__.on = on;
|
22699
|
-
__exports__.off = off;
|
22700
|
-
__exports__.resolve = resolve;
|
22701
|
-
__exports__.reject = reject;
|
22702
|
-
__exports__.async = async;
|
22703
|
-
__exports__.map = map;
|
22704
|
-
__exports__.filter = filter;
|
22705
|
-
});
|
23320
|
+
function F() { }
|
22706
23321
|
|
23322
|
+
var o_create = (Object.create || function (o) {
|
23323
|
+
if (arguments.length > 1) {
|
23324
|
+
throw new Error('Second argument not supported');
|
23325
|
+
}
|
23326
|
+
if (typeof o !== 'object') {
|
23327
|
+
throw new TypeError('Argument must be an object');
|
23328
|
+
}
|
23329
|
+
F.prototype = o;
|
23330
|
+
return new F();
|
23331
|
+
});
|
23332
|
+
__exports__.o_create = o_create;
|
23333
|
+
});
|
22707
23334
|
requireModule("ember-runtime");
|
22708
23335
|
|
22709
23336
|
})();
|