ember-source 2.2.1 → 2.3.0.beta.1

Sign up to get free protection for your applications and to get access to all the features.
@@ -6,7 +6,7 @@
6
6
  * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
7
7
  * @license Licensed under MIT license
8
8
  * See https://raw.github.com/emberjs/ember.js/master/LICENSE
9
- * @version 2.2.1
9
+ * @version 2.3.0-beta.1
10
10
  */
11
11
 
12
12
  var enifed, requireModule, require, requirejs, Ember;
@@ -43,6 +43,15 @@ var mainContext = this;
43
43
  requirejs = require = requireModule = function(name) {
44
44
  return internalRequire(name, null);
45
45
  }
46
+ require['default'] = require;
47
+
48
+ function missingModule(name, referrerName) {
49
+ if (referrerName) {
50
+ throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
51
+ } else {
52
+ throw new Error('Could not find module ' + name);
53
+ }
54
+ }
46
55
 
47
56
  function internalRequire(name, referrerName) {
48
57
  var exports = seen[name];
@@ -54,24 +63,22 @@ var mainContext = this;
54
63
  exports = seen[name] = {};
55
64
 
56
65
  if (!registry[name]) {
57
- if (referrerName) {
58
- throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
59
- } else {
60
- throw new Error('Could not find module ' + name);
61
- }
66
+ missingModule(name, referrerName);
62
67
  }
63
68
 
64
69
  var mod = registry[name];
65
70
  var deps = mod.deps;
66
71
  var callback = mod.callback;
67
- var reified = [];
68
72
  var length = deps.length;
73
+ var reified = new Array(length);;
69
74
 
70
75
  for (var i = 0; i < length; i++) {
71
76
  if (deps[i] === 'exports') {
72
- reified.push(exports);
77
+ reified[i] = exports;
78
+ } else if (deps[i] === 'require') {
79
+ reified[i] = require;
73
80
  } else {
74
- reified.push(internalRequire(deps[i], name));
81
+ reified[i] = internalRequire(deps[i], name);
75
82
  }
76
83
  }
77
84
 
@@ -543,6 +550,10 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/debug', 'embe
543
550
  _emberMetalFeatures.FEATURES['features-stripped-test'] = true;
544
551
  var featuresWereStripped = true;
545
552
 
553
+ if (_emberMetalFeatures.default('features-stripped-test')) {
554
+ exports.featuresWereStripped = featuresWereStripped = false;
555
+ }
556
+
546
557
  delete _emberMetalFeatures.FEATURES['features-stripped-test'];
547
558
  _warnIfUsingStrippedFeatureFlags(_emberMetalCore.default.ENV.FEATURES, featuresWereStripped);
548
559
 
@@ -726,7 +737,7 @@ enifed('ember-testing/adapters/qunit', ['exports', 'ember-testing/adapters/adapt
726
737
  }
727
738
  });
728
739
  });
729
- enifed('ember-testing/helpers', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-testing/test', 'ember-runtime/ext/rsvp'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalError, _emberMetalRun_loop, _emberViewsSystemJquery, _emberTestingTest, _emberRuntimeExtRsvp) {
740
+ enifed('ember-testing/helpers', ['exports', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-testing/test', 'ember-runtime/ext/rsvp'], function (exports, _emberMetalProperty_get, _emberMetalError, _emberMetalRun_loop, _emberViewsSystemJquery, _emberTestingTest, _emberRuntimeExtRsvp) {
730
741
  'use strict';
731
742
 
732
743
  /**
@@ -813,32 +824,6 @@ enifed('ember-testing/helpers', ['exports', 'ember-metal/debug', 'ember-metal/fe
813
824
  return app.testHelpers.wait();
814
825
  }
815
826
 
816
- function check(app, selector, context) {
817
- var $el = app.testHelpers.findWithAssert(selector, context);
818
- var type = $el.prop('type');
819
-
820
- _emberMetalDebug.assert('To check \'' + selector + '\', the input must be a checkbox', type === 'checkbox');
821
-
822
- if (!$el.prop('checked')) {
823
- app.testHelpers.click(selector, context);
824
- }
825
-
826
- return app.testHelpers.wait();
827
- }
828
-
829
- function uncheck(app, selector, context) {
830
- var $el = app.testHelpers.findWithAssert(selector, context);
831
- var type = $el.prop('type');
832
-
833
- _emberMetalDebug.assert('To uncheck \'' + selector + '\', the input must be a checkbox', type === 'checkbox');
834
-
835
- if ($el.prop('checked')) {
836
- app.testHelpers.click(selector, context);
837
- }
838
-
839
- return app.testHelpers.wait();
840
- }
841
-
842
827
  function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions) {
843
828
  var arity = arguments.length;
844
829
  var context, type, options;
@@ -1217,36 +1202,6 @@ enifed('ember-testing/helpers', ['exports', 'ember-metal/debug', 'ember-metal/fe
1217
1202
  */
1218
1203
  asyncHelper('triggerEvent', triggerEvent);
1219
1204
  });
1220
-
1221
- /**
1222
- Checks a checkbox. Ensures the presence of the `checked` attribute
1223
- Example:
1224
- ```javascript
1225
- check('#remember-me').then(function() {
1226
- // assert something
1227
- });
1228
- ```
1229
- @method check
1230
- @param {String} selector jQuery selector finding an `input[type="checkbox"]`
1231
- element on the DOM to check
1232
- @return {RSVP.Promise}
1233
- @private
1234
- */
1235
-
1236
- /**
1237
- Unchecks a checkbox. Ensures the absence of the `checked` attribute
1238
- Example:
1239
- ```javascript
1240
- uncheck('#remember-me').then(function() {
1241
- // assert something
1242
- });
1243
- ```
1244
- @method check
1245
- @param {String} selector jQuery selector finding an `input[type="checkbox"]`
1246
- element on the DOM to uncheck
1247
- @return {RSVP.Promise}
1248
- @private
1249
- */
1250
1205
  enifed('ember-testing/initializers', ['exports', 'ember-runtime/system/lazy_load'], function (exports, _emberRuntimeSystemLazy_load) {
1251
1206
  'use strict';
1252
1207
 
@@ -6,7 +6,7 @@
6
6
  * Portions Copyright 2008-2011 Apple Inc. All rights reserved.
7
7
  * @license Licensed under MIT license
8
8
  * See https://raw.github.com/emberjs/ember.js/master/LICENSE
9
- * @version 2.2.1
9
+ * @version 2.3.0-beta.1
10
10
  */
11
11
 
12
12
  var enifed, requireModule, require, requirejs, Ember;
@@ -43,6 +43,15 @@ var mainContext = this;
43
43
  requirejs = require = requireModule = function(name) {
44
44
  return internalRequire(name, null);
45
45
  }
46
+ require['default'] = require;
47
+
48
+ function missingModule(name, referrerName) {
49
+ if (referrerName) {
50
+ throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
51
+ } else {
52
+ throw new Error('Could not find module ' + name);
53
+ }
54
+ }
46
55
 
47
56
  function internalRequire(name, referrerName) {
48
57
  var exports = seen[name];
@@ -54,24 +63,22 @@ var mainContext = this;
54
63
  exports = seen[name] = {};
55
64
 
56
65
  if (!registry[name]) {
57
- if (referrerName) {
58
- throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
59
- } else {
60
- throw new Error('Could not find module ' + name);
61
- }
66
+ missingModule(name, referrerName);
62
67
  }
63
68
 
64
69
  var mod = registry[name];
65
70
  var deps = mod.deps;
66
71
  var callback = mod.callback;
67
- var reified = [];
68
72
  var length = deps.length;
73
+ var reified = new Array(length);;
69
74
 
70
75
  for (var i = 0; i < length; i++) {
71
76
  if (deps[i] === 'exports') {
72
- reified.push(exports);
77
+ reified[i] = exports;
78
+ } else if (deps[i] === 'require') {
79
+ reified[i] = require;
73
80
  } else {
74
- reified.push(internalRequire(deps[i], name));
81
+ reified[i] = internalRequire(deps[i], name);
75
82
  }
76
83
  }
77
84
 
@@ -1182,7 +1189,7 @@ enifed('backburner', ['exports', 'backburner/utils', 'backburner/platform', 'bac
1182
1189
  clearTimeout(item[2]);
1183
1190
  }
1184
1191
  });
1185
- enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/dictionary', 'ember-metal/features'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalDictionary, _emberMetalFeatures) {
1192
+ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/dictionary', 'ember-metal/features', 'container/owner', 'ember-runtime/mixins/container_proxy'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalDictionary, _emberMetalFeatures, _containerOwner, _emberRuntimeMixinsContainer_proxy) {
1186
1193
  'use strict';
1187
1194
 
1188
1195
  /**
@@ -1200,12 +1207,22 @@ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug
1200
1207
  */
1201
1208
  function Container(registry, options) {
1202
1209
  this.registry = registry;
1210
+ this.owner = options && options.owner ? options.owner : null;
1203
1211
  this.cache = _emberMetalDictionary.default(options && options.cache ? options.cache : null);
1204
1212
  this.factoryCache = _emberMetalDictionary.default(options && options.factoryCache ? options.factoryCache : null);
1205
1213
  this.validationCache = _emberMetalDictionary.default(options && options.validationCache ? options.validationCache : null);
1214
+
1215
+ this._fakeContainerToInject = _emberRuntimeMixinsContainer_proxy.buildFakeContainerWithDeprecations(this);
1206
1216
  }
1207
1217
 
1208
1218
  Container.prototype = {
1219
+ /**
1220
+ @private
1221
+ @property owner
1222
+ @type Object
1223
+ */
1224
+ owner: null,
1225
+
1209
1226
  /**
1210
1227
  @private
1211
1228
  @property registry
@@ -1346,17 +1363,17 @@ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug
1346
1363
  return !!injections._dynamic;
1347
1364
  }
1348
1365
 
1349
- function buildInjections(container) {
1366
+ function buildInjections() /* container, ...injections */{
1350
1367
  var hash = {};
1351
1368
 
1352
1369
  if (arguments.length > 1) {
1353
- var injectionArgs = Array.prototype.slice.call(arguments, 1);
1370
+ var container = arguments[0];
1354
1371
  var injections = [];
1355
1372
  var injection;
1356
1373
 
1357
- for (var i = 0, l = injectionArgs.length; i < l; i++) {
1358
- if (injectionArgs[i]) {
1359
- injections = injections.concat(injectionArgs[i]);
1374
+ for (var i = 1, l = arguments.length; i < l; i++) {
1375
+ if (arguments[i]) {
1376
+ injections = injections.concat(arguments[i]);
1360
1377
  }
1361
1378
  }
1362
1379
 
@@ -1403,6 +1420,11 @@ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug
1403
1420
  factoryInjections._toString = registry.makeToString(factory, fullName);
1404
1421
 
1405
1422
  var injectedFactory = factory.extend(injections);
1423
+
1424
+ // TODO - remove all `container` injections when Ember reaches v3.0.0
1425
+
1426
+ injectDeprecatedContainer(injectedFactory.prototype, container);
1427
+
1406
1428
  injectedFactory.reopenClass(factoryInjections);
1407
1429
 
1408
1430
  if (factory && typeof factory._onLookup === 'function') {
@@ -1424,7 +1446,8 @@ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug
1424
1446
 
1425
1447
  var injections = buildInjections(container, registry.getTypeInjections(type), registry.getInjections(fullName));
1426
1448
  injections._debugContainerKey = fullName;
1427
- injections.container = container;
1449
+
1450
+ _containerOwner.setOwner(injections, container.owner);
1428
1451
 
1429
1452
  return injections;
1430
1453
  }
@@ -1465,18 +1488,47 @@ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug
1465
1488
 
1466
1489
  validationCache[fullName] = true;
1467
1490
 
1491
+ var obj = undefined;
1492
+
1468
1493
  if (typeof factory.extend === 'function') {
1469
1494
  // assume the factory was extendable and is already injected
1470
- return factory.create();
1495
+ obj = factory.create();
1471
1496
  } else {
1472
1497
  // assume the factory was extendable
1473
1498
  // to create time injections
1474
1499
  // TODO: support new'ing for instantiation and merge injections for pure JS Functions
1475
- return factory.create(injectionsFor(container, fullName));
1500
+ var injections = injectionsFor(container, fullName);
1501
+
1502
+ // Ensure that a container is available to an object during instantiation.
1503
+ // TODO - remove when Ember reaches v3.0.0
1504
+
1505
+ // This "fake" container will be replaced after instantiation with a
1506
+ // property that raises deprecations every time it is accessed.
1507
+ injections.container = container._fakeContainerToInject;
1508
+
1509
+ obj = factory.create(injections);
1510
+
1511
+ // TODO - remove when Ember reaches v3.0.0
1512
+
1513
+ injectDeprecatedContainer(obj, container);
1476
1514
  }
1515
+
1516
+ return obj;
1477
1517
  }
1478
1518
  }
1479
1519
 
1520
+ // TODO - remove when Ember reaches v3.0.0
1521
+ function injectDeprecatedContainer(object, container) {
1522
+ Object.defineProperty(object, 'container', {
1523
+ configurable: true,
1524
+ enumerable: false,
1525
+ get: function () {
1526
+ _emberMetalDebug.deprecate('Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.', false, { id: 'ember-application.injected-container', until: '3.0.0', url: 'http://emberjs.com/deprecations/v2.x#toc_injected-container-access' });
1527
+ return container;
1528
+ }
1529
+ });
1530
+ }
1531
+
1480
1532
  function eachDestroyable(container, callback) {
1481
1533
  var cache = container.cache;
1482
1534
  var keys = Object.keys(cache);
@@ -1516,10 +1568,80 @@ enifed('container/container', ['exports', 'ember-metal/core', 'ember-metal/debug
1516
1568
  }
1517
1569
  }
1518
1570
 
1519
- // Once registry / container reform is enabled, we no longer need to expose
1520
- // Container#_registry, since Container itself will be fully private.
1521
1571
  exports.default = Container;
1522
1572
  });
1573
+ enifed('container/owner', ['exports', 'ember-metal/symbol'], function (exports, _emberMetalSymbol) {
1574
+ /**
1575
+ @module ember
1576
+ @submodule ember-runtime
1577
+ */
1578
+
1579
+ 'use strict';
1580
+
1581
+ exports.getOwner = getOwner;
1582
+ exports.setOwner = setOwner;
1583
+ var OWNER = _emberMetalSymbol.default('OWNER');
1584
+
1585
+ exports.OWNER = OWNER;
1586
+ /**
1587
+ Framework objects in an Ember application (components, services, routes, etc.)
1588
+ are created via a factory and dependency injection system. Each of these
1589
+ objects is the responsibility of an "owner", which handled its
1590
+ instantiation and manages its lifetime.
1591
+
1592
+ `getOwner` fetches the owner object responsible for an instance. This can
1593
+ be used to lookup or resolve other class instances, or register new factories
1594
+ into the owner.
1595
+
1596
+ For example, this component dynamically looks up a service based on the
1597
+ `audioType` passed as an attribute:
1598
+
1599
+ ```
1600
+ // app/components/play-audio.js
1601
+ import Ember from 'ember';
1602
+
1603
+ // Usage:
1604
+ //
1605
+ // {{play-audio audioType=model.audioType audioFile=model.file}}
1606
+ //
1607
+ export default Ember.Component.extend({
1608
+ audioService: Ember.computed('audioType', function() {
1609
+ let owner = Ember.getOwner(this);
1610
+ return owner.lookup(`service:${this.get('audioType')}`);
1611
+ }),
1612
+ click() {
1613
+ let player = this.get('audioService');
1614
+ player.play(this.get('audioFile'));
1615
+ }
1616
+ });
1617
+ ```
1618
+
1619
+ @method getOwner
1620
+ @param {Object} object A object with an owner.
1621
+ @return {Object} an owner object.
1622
+ @for Ember
1623
+ @public
1624
+ */
1625
+
1626
+ function getOwner(object) {
1627
+ return object[OWNER];
1628
+ }
1629
+
1630
+ /**
1631
+ `setOwner` forces a new owner on a given object instance. This is primarily
1632
+ useful in some testing cases.
1633
+
1634
+ @method setOwner
1635
+ @param {Object} object A object with an owner.
1636
+ @return {Object} an owner object.
1637
+ @for Ember
1638
+ @public
1639
+ */
1640
+
1641
+ function setOwner(object, owner) {
1642
+ object[OWNER] = owner;
1643
+ }
1644
+ });
1523
1645
  enifed('container/registry', ['exports', 'ember-metal/debug', 'ember-metal/dictionary', 'ember-metal/assign', 'container/container'], function (exports, _emberMetalDebug, _emberMetalDictionary, _emberMetalAssign, _containerContainer) {
1524
1646
  'use strict';
1525
1647
 
@@ -2182,7 +2304,7 @@ enifed('container/registry', ['exports', 'ember-metal/debug', 'ember-metal/dicti
2182
2304
 
2183
2305
  exports.default = Registry;
2184
2306
  });
2185
- enifed('container', ['exports', 'ember-metal/core', 'container/registry', 'container/container'], function (exports, _emberMetalCore, _containerRegistry, _containerContainer) {
2307
+ enifed('container', ['exports', 'ember-metal/core', 'container/registry', 'container/container', 'container/owner'], function (exports, _emberMetalCore, _containerRegistry, _containerContainer, _containerOwner) {
2186
2308
  'use strict';
2187
2309
 
2188
2310
  /*
@@ -2205,6 +2327,8 @@ enifed('container', ['exports', 'ember-metal/core', 'container/registry', 'conta
2205
2327
 
2206
2328
  exports.Registry = _containerRegistry.default;
2207
2329
  exports.Container = _containerContainer.default;
2330
+ exports.getOwner = _containerOwner.getOwner;
2331
+ exports.setOwner = _containerOwner.setOwner;
2208
2332
  });
2209
2333
  enifed('dag-map/platform', ['exports'], function (exports) {
2210
2334
  'use strict';
@@ -3474,8 +3598,6 @@ enifed('ember-application/system/application-instance', ['exports', 'ember-metal
3474
3598
 
3475
3599
  var application = _emberMetalProperty_get.get(this, 'application');
3476
3600
 
3477
- _emberMetalProperty_set.set(this, 'rootElement', _emberMetalProperty_get.get(application, 'rootElement'));
3478
-
3479
3601
  // Create a per-instance registry that will use the application's registry
3480
3602
  // as a fallback for resolving registrations.
3481
3603
  var applicationRegistry = _emberMetalProperty_get.get(application, '__registry__');
@@ -3486,7 +3608,7 @@ enifed('ember-application/system/application-instance', ['exports', 'ember-metal
3486
3608
  registry.makeToString = applicationRegistry.makeToString;
3487
3609
 
3488
3610
  // Create a per-instance container from the instance's registry
3489
- this.__container__ = registry.container();
3611
+ this.__container__ = registry.container({ owner: this });
3490
3612
 
3491
3613
  // Register this instance in the per-instance registry.
3492
3614
  //
@@ -3542,9 +3664,34 @@ enifed('ember-application/system/application-instance', ['exports', 'ember-metal
3542
3664
  return this;
3543
3665
  }
3544
3666
 
3667
+ options = new BootOptions(options);
3668
+
3669
+ var registry = this.__registry__;
3670
+
3671
+ registry.register('-environment:main', options.toEnvironment(), { instantiate: false });
3672
+ registry.injection('view', '_environment', '-environment:main');
3673
+ registry.injection('route', '_environment', '-environment:main');
3674
+
3675
+ registry.register('renderer:-dom', {
3676
+ create: function () {
3677
+ return new _emberMetalViewsRenderer.default(new _emberHtmlbarsSystemDomHelper.default(options.document), options.isInteractive);
3678
+ }
3679
+ });
3680
+
3681
+ if (options.rootElement) {
3682
+ this.rootElement = options.rootElement;
3683
+ } else {
3684
+ this.rootElement = this.application.rootElement;
3685
+ }
3686
+
3687
+ if (options.location) {
3688
+ var router = _emberMetalProperty_get.get(this, 'router');
3689
+ _emberMetalProperty_set.set(router, 'location', options.location);
3690
+ }
3691
+
3545
3692
  this.application.runInstanceInitializers(this);
3546
3693
 
3547
- if (_emberMetalEnvironment.default.hasDOM) {
3694
+ if (options.isInteractive) {
3548
3695
  this.setupEventDispatcher();
3549
3696
  }
3550
3697
 
@@ -3636,6 +3783,235 @@ enifed('ember-application/system/application-instance', ['exports', 'ember-metal
3636
3783
  }
3637
3784
  });
3638
3785
 
3786
+ ApplicationInstance.reopen({
3787
+ /**
3788
+ Returns the current URL of the app instance. This is useful when your
3789
+ app does not update the browsers URL bar (i.e. it uses the `'none'`
3790
+ location adapter).
3791
+ @public
3792
+ @return {String} the current URL
3793
+ */
3794
+ getURL: function () {
3795
+ var router = _emberMetalProperty_get.get(this, 'router');
3796
+ return _emberMetalProperty_get.get(router, 'url');
3797
+ },
3798
+
3799
+ // `instance.visit(url)` should eventually replace `instance.handleURL()`;
3800
+ // the test helpers can probably be switched to use this implementation too
3801
+
3802
+ /**
3803
+ Navigate the instance to a particular URL. This is useful in tests, for
3804
+ example, or to tell the app to start at a particular URL. This method
3805
+ returns a promise that resolves with the app instance when the transition
3806
+ is complete, or rejects if the transion was aborted due to an error.
3807
+ @public
3808
+ @param url {String} the destination URL
3809
+ @return {Promise}
3810
+ */
3811
+ visit: function (url) {
3812
+ var _this2 = this;
3813
+
3814
+ this.setupRouter();
3815
+
3816
+ var router = _emberMetalProperty_get.get(this, 'router');
3817
+
3818
+ var handleResolve = function () {
3819
+ // Resolve only after rendering is complete
3820
+ return new _emberRuntimeExtRsvp.default.Promise(function (resolve) {
3821
+ // TODO: why is this necessary? Shouldn't 'actions' queue be enough?
3822
+ // Also, aren't proimses supposed to be async anyway?
3823
+ _emberMetalRun_loop.default.next(null, resolve, _this2);
3824
+ });
3825
+ };
3826
+
3827
+ var handleReject = function (error) {
3828
+ if (error.error) {
3829
+ throw error.error;
3830
+ } else if (error.name === 'TransitionAborted' && router.router.activeTransition) {
3831
+ return router.router.activeTransition.then(handleResolve, handleReject);
3832
+ } else if (error.name === 'TransitionAborted') {
3833
+ throw new Error(error.message);
3834
+ } else {
3835
+ throw error;
3836
+ }
3837
+ };
3838
+
3839
+ // Keeps the location adapter's internal URL in-sync
3840
+ _emberMetalProperty_get.get(router, 'location').setURL(url);
3841
+
3842
+ return router.handleURL(url).then(handleResolve, handleReject);
3843
+ }
3844
+ });
3845
+
3846
+ /**
3847
+ A list of boot-time configuration options for customizing the behavior of
3848
+ an `Ember.ApplicationInstance`.
3849
+ This is an interface class that exists purely to document the available
3850
+ options; you do not need to construct it manually. Simply pass a regular
3851
+ JavaScript object containing the desired options into methods that require
3852
+ one of these options object:
3853
+ ```javascript
3854
+ MyApp.visit("/", { location: "none", rootElement: "#container" });
3855
+ ```
3856
+ Not all combinations of the supported options are valid. See the documentation
3857
+ on `Ember.Application#visit` for the supported configurations.
3858
+ Internal, experimental or otherwise unstable flags are marked as private.
3859
+ @class BootOptions
3860
+ @namespace @Ember.ApplicationInstance
3861
+ @public
3862
+ */
3863
+ BootOptions = function BootOptions() {
3864
+ var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
3865
+
3866
+ /**
3867
+ Provide a specific instance of jQuery. This is useful in conjunction with
3868
+ the `document` option, as it allows you to use a copy of `jQuery` that is
3869
+ appropriately bound to the foreign `document` (e.g. a jsdom).
3870
+ This is highly experimental and support very incomplete at the moment.
3871
+ @property jQuery
3872
+ @type Object
3873
+ @default auto-detected
3874
+ @private
3875
+ */
3876
+ this.jQuery = _emberViewsSystemJquery.default; // This default is overridable below
3877
+
3878
+ /**
3879
+ Interactive mode: whether we need to set up event delegation and invoke
3880
+ lifecycle callbacks on Components.
3881
+ @property isInteractive
3882
+ @type boolean
3883
+ @default auto-detected
3884
+ @private
3885
+ */
3886
+ this.isInteractive = _emberMetalEnvironment.default.hasDOM; // This default is overridable below
3887
+
3888
+ /**
3889
+ Run in a full browser environment.
3890
+ When this flag is set to `false`, it will disable most browser-specific
3891
+ and interactive features. Specifically:
3892
+ * It does not use `jQuery` to append the root view; the `rootElement`
3893
+ (either specified as a subsequent option or on the application itself)
3894
+ must already be an `Element` in the given `document` (as opposed to a
3895
+ string selector).
3896
+ * It does not set up an `EventDispatcher`.
3897
+ * It does not run any `Component` lifecycle hooks (such as `didInsertElement`).
3898
+ * It sets the `location` option to `"none"`. (If you would like to use
3899
+ the location adapter specified in the app's router instead, you can also
3900
+ specify `{ location: null }` to specifically opt-out.)
3901
+ @property isBrowser
3902
+ @type boolean
3903
+ @default auto-detected
3904
+ @public
3905
+ */
3906
+ if (options.isBrowser !== undefined) {
3907
+ this.isBrowser = !!options.isBrowser;
3908
+ } else {
3909
+ this.isBrowser = _emberMetalEnvironment.default.hasDOM;
3910
+ }
3911
+
3912
+ if (!this.isBrowser) {
3913
+ this.jQuery = null;
3914
+ this.isInteractive = false;
3915
+ this.location = 'none';
3916
+ }
3917
+
3918
+ /**
3919
+ Disable rendering completely.
3920
+ When this flag is set to `true`, it will disable the entire rendering
3921
+ pipeline. Essentially, this puts the app into "routing-only" mode. No
3922
+ templates will be rendered, and no Components will be created.
3923
+ @property shouldRender
3924
+ @type boolean
3925
+ @default true
3926
+ @public
3927
+ */
3928
+ if (options.shouldRender !== undefined) {
3929
+ this.shouldRender = !!options.shouldRender;
3930
+ } else {
3931
+ this.shouldRender = true;
3932
+ }
3933
+
3934
+ if (!this.shouldRender) {
3935
+ this.jQuery = null;
3936
+ this.isInteractive = false;
3937
+ }
3938
+
3939
+ /**
3940
+ If present, render into the given `Document` object instead of the
3941
+ global `window.document` object.
3942
+ In practice, this is only useful in non-browser environment or in
3943
+ non-interactive mode, because Ember's `jQuery` dependency is
3944
+ implicitly bound to the current document, causing event delegation
3945
+ to not work properly when the app is rendered into a foreign
3946
+ document object (such as an iframe's `contentDocument`).
3947
+ In non-browser mode, this could be a "`Document`-like" object as
3948
+ Ember only interact with a small subset of the DOM API in non-
3949
+ interactive mode. While the exact requirements have not yet been
3950
+ formalized, the `SimpleDOM` library's implementation is known to
3951
+ work.
3952
+ @property document
3953
+ @type Document
3954
+ @default the global `document` object
3955
+ @public
3956
+ */
3957
+ if (options.document) {
3958
+ this.document = options.document;
3959
+ } else {
3960
+ this.document = typeof document !== 'undefined' ? document : null;
3961
+ }
3962
+
3963
+ /**
3964
+ If present, overrides the application's `rootElement` property on
3965
+ the instance. This is useful for testing environment, where you
3966
+ might want to append the root view to a fixture area.
3967
+ In non-browser mode, because Ember does not have access to jQuery,
3968
+ this options must be specified as a DOM `Element` object instead of
3969
+ a selector string.
3970
+ See the documentation on `Ember.Applications`'s `rootElement` for
3971
+ details.
3972
+ @property rootElement
3973
+ @type String|Element
3974
+ @default null
3975
+ @public
3976
+ */
3977
+ if (options.rootElement) {
3978
+ this.rootElement = options.rootElement;
3979
+ }
3980
+
3981
+ // Set these options last to give the user a chance to override the
3982
+ // defaults from the "combo" options like `isBrowser` (although in
3983
+ // practice, the resulting combination is probably invalid)
3984
+
3985
+ /**
3986
+ If present, overrides the router's `location` property with this
3987
+ value. This is useful for environments where trying to modify the
3988
+ URL would be inappropriate.
3989
+ @property location
3990
+ @type string
3991
+ @default null
3992
+ @public
3993
+ */
3994
+ if (options.location !== undefined) {
3995
+ this.location = options.location;
3996
+ }
3997
+
3998
+ if (options.jQuery !== undefined) {
3999
+ this.jQuery = options.jQuery;
4000
+ }
4001
+
4002
+ if (options.isInteractive !== undefined) {
4003
+ this.isInteractive = !!options.isInteractive;
4004
+ }
4005
+ };
4006
+
4007
+ BootOptions.prototype.toEnvironment = function () {
4008
+ var env = _emberMetalAssign.default({}, _emberMetalEnvironment.default);
4009
+ // For compatibility with existing code
4010
+ env.hasDOM = this.isBrowser;
4011
+ env.options = this;
4012
+ return env;
4013
+ };
4014
+
3639
4015
  function isResolverModuleBased(applicationInstance) {
3640
4016
  return !!applicationInstance.application.__registry__.resolver.moduleBasedResolver;
3641
4017
  }
@@ -3665,156 +4041,9 @@ enifed('ember-application/system/application-instance', ['exports', 'ember-metal
3665
4041
  return _emberRuntimeMixinsRegistry_proxy.buildFakeRegistryWithDeprecations(this, 'ApplicationInstance');
3666
4042
  }
3667
4043
  });
4044
+
3668
4045
  exports.default = ApplicationInstance;
3669
4046
  });
3670
-
3671
- /**
3672
- Returns the current URL of the app instance. This is useful when your
3673
- app does not update the browsers URL bar (i.e. it uses the `'none'`
3674
- location adapter).
3675
- @public
3676
- @return {String} the current URL
3677
- */
3678
-
3679
- // `instance.visit(url)` should eventually replace `instance.handleURL()`;
3680
- // the test helpers can probably be switched to use this implementation too
3681
-
3682
- /**
3683
- Navigate the instance to a particular URL. This is useful in tests, for
3684
- example, or to tell the app to start at a particular URL. This method
3685
- returns a promise that resolves with the app instance when the transition
3686
- is complete, or rejects if the transion was aborted due to an error.
3687
- @public
3688
- @param url {String} the destination URL
3689
- @return {Promise}
3690
- */
3691
-
3692
- // Resolve only after rendering is complete
3693
-
3694
- // TODO: why is this necessary? Shouldn't 'actions' queue be enough?
3695
- // Also, aren't proimses supposed to be async anyway?
3696
-
3697
- // Keeps the location adapter's internal URL in-sync
3698
-
3699
- /**
3700
- A list of boot-time configuration options for customizing the behavior of
3701
- an `Ember.ApplicationInstance`.
3702
- This is an interface class that exists purely to document the available
3703
- options; you do not need to construct it manually. Simply pass a regular
3704
- JavaScript object containing the desired options into methods that require
3705
- one of these options object:
3706
- ```javascript
3707
- MyApp.visit("/", { location: "none", rootElement: "#container" });
3708
- ```
3709
- Not all combinations of the supported options are valid. See the documentation
3710
- on `Ember.Application#visit` for the supported configurations.
3711
- Internal, experimental or otherwise unstable flags are marked as private.
3712
- @class BootOptions
3713
- @namespace @Ember.ApplicationInstance
3714
- @public
3715
- */
3716
-
3717
- /**
3718
- Provide a specific instance of jQuery. This is useful in conjunction with
3719
- the `document` option, as it allows you to use a copy of `jQuery` that is
3720
- appropriately bound to the foreign `document` (e.g. a jsdom).
3721
- This is highly experimental and support very incomplete at the moment.
3722
- @property jQuery
3723
- @type Object
3724
- @default auto-detected
3725
- @private
3726
- */
3727
- // This default is overridable below
3728
-
3729
- /**
3730
- Interactive mode: whether we need to set up event delegation and invoke
3731
- lifecycle callbacks on Components.
3732
- @property isInteractive
3733
- @type boolean
3734
- @default auto-detected
3735
- @private
3736
- */
3737
- // This default is overridable below
3738
-
3739
- /**
3740
- Run in a full browser environment.
3741
- When this flag is set to `false`, it will disable most browser-specific
3742
- and interactive features. Specifically:
3743
- * It does not use `jQuery` to append the root view; the `rootElement`
3744
- (either specified as a subsequent option or on the application itself)
3745
- must already be an `Element` in the given `document` (as opposed to a
3746
- string selector).
3747
- * It does not set up an `EventDispatcher`.
3748
- * It does not run any `Component` lifecycle hooks (such as `didInsertElement`).
3749
- * It sets the `location` option to `"none"`. (If you would like to use
3750
- the location adapter specified in the app's router instead, you can also
3751
- specify `{ location: null }` to specifically opt-out.)
3752
- @property isBrowser
3753
- @type boolean
3754
- @default auto-detected
3755
- @public
3756
- */
3757
-
3758
- /**
3759
- Disable rendering completely.
3760
- When this flag is set to `true`, it will disable the entire rendering
3761
- pipeline. Essentially, this puts the app into "routing-only" mode. No
3762
- templates will be rendered, and no Components will be created.
3763
- @property shouldRender
3764
- @type boolean
3765
- @default true
3766
- @public
3767
- */
3768
-
3769
- /**
3770
- If present, render into the given `Document` object instead of the
3771
- global `window.document` object.
3772
- In practice, this is only useful in non-browser environment or in
3773
- non-interactive mode, because Ember's `jQuery` dependency is
3774
- implicitly bound to the current document, causing event delegation
3775
- to not work properly when the app is rendered into a foreign
3776
- document object (such as an iframe's `contentDocument`).
3777
- In non-browser mode, this could be a "`Document`-like" object as
3778
- Ember only interact with a small subset of the DOM API in non-
3779
- interactive mode. While the exact requirements have not yet been
3780
- formalized, the `SimpleDOM` library's implementation is known to
3781
- work.
3782
- @property document
3783
- @type Document
3784
- @default the global `document` object
3785
- @public
3786
- */
3787
-
3788
- /**
3789
- If present, overrides the application's `rootElement` property on
3790
- the instance. This is useful for testing environment, where you
3791
- might want to append the root view to a fixture area.
3792
- In non-browser mode, because Ember does not have access to jQuery,
3793
- this options must be specified as a DOM `Element` object instead of
3794
- a selector string.
3795
- See the documentation on `Ember.Applications`'s `rootElement` for
3796
- details.
3797
- @property rootElement
3798
- @type String|Element
3799
- @default null
3800
- @public
3801
- */
3802
-
3803
- // Set these options last to give the user a chance to override the
3804
- // defaults from the "combo" options like `isBrowser` (although in
3805
- // practice, the resulting combination is probably invalid)
3806
-
3807
- /**
3808
- If present, overrides the router's `location` property with this
3809
- value. This is useful for environments where trying to modify the
3810
- URL would be inappropriate.
3811
- @property location
3812
- @type string
3813
- @default null
3814
- @public
3815
- */
3816
-
3817
- // For compatibility with existing code
3818
4047
  enifed('ember-application/system/application', ['exports', 'dag-map', 'container/registry', 'ember-metal', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/empty_object', 'ember-runtime/system/lazy_load', 'ember-runtime/system/namespace', 'ember-application/system/resolver', 'ember-metal/run_loop', 'ember-metal/utils', 'ember-runtime/controllers/controller', 'ember-metal-views/renderer', 'ember-htmlbars/system/dom-helper', 'ember-views/views/select', 'ember-routing-views/views/outlet', 'ember-views/views/view', 'ember-views/system/event_dispatcher', 'ember-views/system/jquery', 'ember-routing/system/route', 'ember-routing/system/router', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/location/none_location', 'ember-routing/system/cache', 'ember-application/system/application-instance', 'ember-views/views/text_field', 'ember-views/views/text_area', 'ember-views/views/checkbox', 'ember-views/views/legacy_each_view', 'ember-routing-views/components/link-to', 'ember-routing/services/routing', 'ember-extension-support/container_debug_adapter', 'ember-runtime/mixins/registry_proxy', 'ember-metal/environment', 'ember-runtime/ext/rsvp'], function (exports, _dagMap, _containerRegistry, _emberMetal, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalEmpty_object, _emberRuntimeSystemLazy_load, _emberRuntimeSystemNamespace, _emberApplicationSystemResolver, _emberMetalRun_loop, _emberMetalUtils, _emberRuntimeControllersController, _emberMetalViewsRenderer, _emberHtmlbarsSystemDomHelper, _emberViewsViewsSelect, _emberRoutingViewsViewsOutlet, _emberViewsViewsView, _emberViewsSystemEvent_dispatcher, _emberViewsSystemJquery, _emberRoutingSystemRoute, _emberRoutingSystemRouter, _emberRoutingLocationHash_location, _emberRoutingLocationHistory_location, _emberRoutingLocationAuto_location, _emberRoutingLocationNone_location, _emberRoutingSystemCache, _emberApplicationSystemApplicationInstance, _emberViewsViewsText_field, _emberViewsViewsText_area, _emberViewsViewsCheckbox, _emberViewsViewsLegacy_each_view, _emberRoutingViewsComponentsLinkTo, _emberRoutingServicesRouting, _emberExtensionSupportContainer_debug_adapter, _emberRuntimeMixinsRegistry_proxy, _emberMetalEnvironment, _emberRuntimeExtRsvp) {
3819
4048
  /**
3820
4049
  @module ember
@@ -4127,12 +4356,15 @@ enifed('ember-application/system/application', ['exports', 'dag-map', 'container
4127
4356
  this._readinessDeferrals = 1;
4128
4357
  this._booted = false;
4129
4358
 
4130
- // Force-assign these flags to their default values when the feature is
4131
- // disabled, this ensures we can rely on their values in other paths.
4132
- this.autoboot = this._globalsMode = true;
4359
+ this.autoboot = this._globalsMode = !!this.autoboot;
4360
+
4361
+ if (this._globalsMode) {
4362
+ this._prepareForGlobalsMode();
4363
+ }
4133
4364
 
4134
- this._prepareForGlobalsMode();
4135
- this.waitForDOMReady();
4365
+ if (this.autoboot) {
4366
+ this.waitForDOMReady();
4367
+ }
4136
4368
  },
4137
4369
 
4138
4370
  /**
@@ -4512,11 +4744,29 @@ enifed('ember-application/system/application', ['exports', 'dag-map', 'container
4512
4744
  _emberMetal.default.BOOTED = true;
4513
4745
  }
4514
4746
 
4515
- var instance = this.__deprecatedInstance__;
4747
+ // See documentation on `_autoboot()` for details
4748
+ if (this.autoboot) {
4749
+ var instance = undefined;
4516
4750
 
4517
- instance._bootSync();
4518
- this.ready();
4519
- instance.startRouting();
4751
+ if (this._globalsMode) {
4752
+ // If we already have the __deprecatedInstance__ lying around, boot it to
4753
+ // avoid unnecessary work
4754
+ instance = this.__deprecatedInstance__;
4755
+ } else {
4756
+ // Otherwise, build an instance and boot it. This is currently unreachable,
4757
+ // because we forced _globalsMode to === autoboot; but having this branch
4758
+ // allows us to locally toggle that flag for weeding out legacy globals mode
4759
+ // dependencies independently
4760
+ instance = this.buildInstance();
4761
+ }
4762
+
4763
+ instance._bootSync();
4764
+
4765
+ // TODO: App.ready() is not called when autoboot is disabled, is this correct?
4766
+ this.ready();
4767
+
4768
+ instance.startRouting();
4769
+ }
4520
4770
 
4521
4771
  // For the asynchronous boot path
4522
4772
  this._bootResolver.resolve(this);
@@ -4644,6 +4894,170 @@ enifed('ember-application/system/application', ['exports', 'dag-map', 'container
4644
4894
  instanceInitializer: buildInitializerMethod('instanceInitializers', 'instance initializer')
4645
4895
  });
4646
4896
 
4897
+ Application.reopen({
4898
+ /**
4899
+ Boot a new instance of `Ember.ApplicationInstance` for the current
4900
+ application and navigate it to the given `url`. Returns a `Promise` that
4901
+ resolves with the instance when the initial routing and rendering is
4902
+ complete, or rejects with any error that occured during the boot process.
4903
+ When `autoboot` is disabled, calling `visit` would first cause the
4904
+ application to boot, which runs the application initializers.
4905
+ This method also takes a hash of boot-time configuration options for
4906
+ customizing the instance's behavior. See the documentation on
4907
+ `Ember.ApplicationInstance.BootOptions` for details.
4908
+ `Ember.ApplicationInstance.BootOptions` is an interface class that exists
4909
+ purely to document the available options; you do not need to construct it
4910
+ manually. Simply pass a regular JavaScript object containing of the
4911
+ desired options:
4912
+ ```javascript
4913
+ MyApp.visit("/", { location: "none", rootElement: "#container" });
4914
+ ```
4915
+ ### Supported Scenarios
4916
+ While the `BootOptions` class exposes a large number of knobs, not all
4917
+ combinations of them are valid; certain incompatible combinations might
4918
+ result in unexpected behavior.
4919
+ For example, booting the instance in the full browser environment
4920
+ while specifying a foriegn `document` object (e.g. `{ isBrowser: true,
4921
+ document: iframe.contentDocument }`) does not work correctly today,
4922
+ largely due to Ember's jQuery dependency.
4923
+ Currently, there are three officially supported scenarios/configurations.
4924
+ Usages outside of these scenarios are not guaranteed to work, but please
4925
+ feel free to file bug reports documenting your experience and any issues
4926
+ you encountered to help expand support.
4927
+ #### Browser Applications (Manual Boot)
4928
+ The setup is largely similar to how Ember works out-of-the-box. Normally,
4929
+ Ember will boot a default instance for your Application on "DOM ready".
4930
+ However, you can customize this behavior by disabling `autoboot`.
4931
+ For example, this allows you to render a miniture demo of your application
4932
+ into a specific area on your marketing website:
4933
+ ```javascript
4934
+ import MyApp from 'my-app';
4935
+ $(function() {
4936
+ let App = MyApp.create({ autoboot: false });
4937
+ let options = {
4938
+ // Override the router's location adapter to prevent it from updating
4939
+ // the URL in the address bar
4940
+ location: 'none',
4941
+ // Override the default `rootElement` on the app to render into a
4942
+ // specific `div` on the page
4943
+ rootElement: '#demo'
4944
+ };
4945
+ // Start the app at the special demo URL
4946
+ App.visit('/demo', options);
4947
+ });
4948
+ ````
4949
+ Or perhaps you might want to boot two instances of your app on the same
4950
+ page for a split-screen multiplayer experience:
4951
+ ```javascript
4952
+ import MyApp from 'my-app';
4953
+ $(function() {
4954
+ let App = MyApp.create({ autoboot: false });
4955
+ let sessionId = MyApp.generateSessionID();
4956
+ let player1 = App.visit(`/matches/join?name=Player+1&session=${sessionId}`, { rootElement: '#left', location: 'none' });
4957
+ let player2 = App.visit(`/matches/join?name=Player+2&session=${sessionId}`, { rootElement: '#right', location: 'none' });
4958
+ Promise.all([player1, player2]).then(() => {
4959
+ // Both apps have completed the initial render
4960
+ $('#loading').fadeOut();
4961
+ });
4962
+ });
4963
+ ```
4964
+ Do note that each app instance maintains their own registry/container, so
4965
+ they will run in complete isolation by default.
4966
+ #### Server-Side Rendering (also known as FastBoot)
4967
+ This setup allows you to run your Ember app in a server environment using
4968
+ Node.js and render its content into static HTML for SEO purposes.
4969
+ ```javascript
4970
+ const HTMLSerializer = new SimpleDOM.HTMLSerializer(SimpleDOM.voidMap);
4971
+ function renderURL(url) {
4972
+ let dom = new SimpleDOM.Document();
4973
+ let rootElement = dom.body;
4974
+ let options = { isBrowser: false, document: dom, rootElement: rootElement };
4975
+ return MyApp.visit(options).then(instance => {
4976
+ try {
4977
+ return HTMLSerializer.serialize(rootElement.firstChild);
4978
+ } finally {
4979
+ instance.destroy();
4980
+ }
4981
+ });
4982
+ }
4983
+ ```
4984
+ In this scenario, because Ember does not have access to a global `document`
4985
+ object in the Node.js environment, you must provide one explicitly. In practice,
4986
+ in the non-browser environment, the stand-in `document` object only need to
4987
+ implement a limited subset of the full DOM API. The `SimpleDOM` library is known
4988
+ to work.
4989
+ Since there is no access to jQuery in the non-browser environment, you must also
4990
+ specify a DOM `Element` object in the same `document` for the `rootElement` option
4991
+ (as opposed to a selector string like `"body"`).
4992
+ See the documentation on the `isBrowser`, `document` and `rootElement` properties
4993
+ on `Ember.ApplicationInstance.BootOptions` for details.
4994
+ #### Server-Side Resource Discovery
4995
+ This setup allows you to run the routing layer of your Ember app in a server
4996
+ environment using Node.js and completely disable rendering. This allows you
4997
+ to simulate and discover the resources (i.e. AJAX requests) needed to fufill
4998
+ a given request and eagerly "push" these resources to the client.
4999
+ ```app/initializers/network-service.js
5000
+ import BrowserNetworkService from 'app/services/network/browser';
5001
+ import NodeNetworkService from 'app/services/network/node';
5002
+ // Inject a (hypothetical) service for abstracting all AJAX calls and use
5003
+ // the appropiate implementaion on the client/server. This also allows the
5004
+ // server to log all the AJAX calls made during a particular request and use
5005
+ // that for resource-discovery purpose.
5006
+ export function initialize(application) {
5007
+ if (window) { // browser
5008
+ application.register('service:network', BrowserNetworkService);
5009
+ } else { // node
5010
+ application.register('service:network', NodeNetworkService);
5011
+ }
5012
+ application.inject('route', 'network', 'service:network');
5013
+ };
5014
+ export default {
5015
+ name: 'network-service',
5016
+ initialize: initialize
5017
+ };
5018
+ ```
5019
+ ```app/routes/post.js
5020
+ import Ember from 'ember';
5021
+ // An example of how the (hypothetical) service is used in routes.
5022
+ export default Ember.Route.extend({
5023
+ model(params) {
5024
+ return this.network.fetch(`/api/posts/${params.post_id}.json`);
5025
+ },
5026
+ afterModel(post) {
5027
+ if (post.isExternalContent) {
5028
+ return this.network.fetch(`/api/external/?url=${post.externalURL}`);
5029
+ } else {
5030
+ return post;
5031
+ }
5032
+ }
5033
+ });
5034
+ ```
5035
+ ```javascript
5036
+ // Finally, put all the pieces together
5037
+ function discoverResourcesFor(url) {
5038
+ return MyApp.visit(url, { isBrowser: false, shouldRender: false }).then(instance => {
5039
+ let networkService = instance.lookup('service:network');
5040
+ return networkService.requests; // => { "/api/posts/123.json": "..." }
5041
+ });
5042
+ }
5043
+ ```
5044
+ @method visit
5045
+ @param url {String} The initial URL to navigate to
5046
+ @param options {Ember.ApplicationInstance.BootOptions}
5047
+ @return {Promise<Ember.ApplicationInstance, Error>}
5048
+ @private
5049
+ */
5050
+ visit: function (url, options) {
5051
+ var _this = this;
5052
+
5053
+ return this.boot().then(function () {
5054
+ return _this.buildInstance().boot(options).then(function (instance) {
5055
+ return instance.visit(url);
5056
+ });
5057
+ });
5058
+ }
5059
+ });
5060
+
4647
5061
  Application.reopenClass({
4648
5062
  initializers: new _emberMetalEmpty_object.default(),
4649
5063
  instanceInitializers: new _emberMetalEmpty_object.default(),
@@ -4953,171 +5367,9 @@ enifed('ember-application/system/application', ['exports', 'dag-map', 'container
4953
5367
  });
4954
5368
  // Ember.libraries, LOG_VERSION, Namespace, BOOTED
4955
5369
 
4956
- // See documentation on `_autoboot()` for details
4957
-
4958
- // If we already have the __deprecatedInstance__ lying around, boot it to
4959
- // avoid unnecessary work
4960
-
4961
- // Otherwise, build an instance and boot it. This is currently unreachable,
4962
- // because we forced _globalsMode to === autoboot; but having this branch
4963
- // allows us to locally toggle that flag for weeding out legacy globals mode
4964
- // dependencies independently
4965
-
4966
- // TODO: App.ready() is not called when autoboot is disabled, is this correct?
4967
-
4968
- /**
4969
- Boot a new instance of `Ember.ApplicationInstance` for the current
4970
- application and navigate it to the given `url`. Returns a `Promise` that
4971
- resolves with the instance when the initial routing and rendering is
4972
- complete, or rejects with any error that occured during the boot process.
4973
- When `autoboot` is disabled, calling `visit` would first cause the
4974
- application to boot, which runs the application initializers.
4975
- This method also takes a hash of boot-time configuration options for
4976
- customizing the instance's behavior. See the documentation on
4977
- `Ember.ApplicationInstance.BootOptions` for details.
4978
- `Ember.ApplicationInstance.BootOptions` is an interface class that exists
4979
- purely to document the available options; you do not need to construct it
4980
- manually. Simply pass a regular JavaScript object containing of the
4981
- desired options:
4982
- ```javascript
4983
- MyApp.visit("/", { location: "none", rootElement: "#container" });
4984
- ```
4985
- ### Supported Scenarios
4986
- While the `BootOptions` class exposes a large number of knobs, not all
4987
- combinations of them are valid; certain incompatible combinations might
4988
- result in unexpected behavior.
4989
- For example, booting the instance in the full browser environment
4990
- while specifying a foriegn `document` object (e.g. `{ isBrowser: true,
4991
- document: iframe.contentDocument }`) does not work correctly today,
4992
- largely due to Ember's jQuery dependency.
4993
- Currently, there are three officially supported scenarios/configurations.
4994
- Usages outside of these scenarios are not guaranteed to work, but please
4995
- feel free to file bug reports documenting your experience and any issues
4996
- you encountered to help expand support.
4997
- #### Browser Applications (Manual Boot)
4998
- The setup is largely similar to how Ember works out-of-the-box. Normally,
4999
- Ember will boot a default instance for your Application on "DOM ready".
5000
- However, you can customize this behavior by disabling `autoboot`.
5001
- For example, this allows you to render a miniture demo of your application
5002
- into a specific area on your marketing website:
5003
- ```javascript
5004
- import MyApp from 'my-app';
5005
- $(function() {
5006
- let App = MyApp.create({ autoboot: false });
5007
- let options = {
5008
- // Override the router's location adapter to prevent it from updating
5009
- // the URL in the address bar
5010
- location: 'none',
5011
- // Override the default `rootElement` on the app to render into a
5012
- // specific `div` on the page
5013
- rootElement: '#demo'
5014
- };
5015
- // Start the app at the special demo URL
5016
- App.visit('/demo', options);
5017
- });
5018
- ````
5019
- Or perhaps you might want to boot two instances of your app on the same
5020
- page for a split-screen multiplayer experience:
5021
- ```javascript
5022
- import MyApp from 'my-app';
5023
- $(function() {
5024
- let App = MyApp.create({ autoboot: false });
5025
- let sessionId = MyApp.generateSessionID();
5026
- let player1 = App.visit(`/matches/join?name=Player+1&session=${sessionId}`, { rootElement: '#left', location: 'none' });
5027
- let player2 = App.visit(`/matches/join?name=Player+2&session=${sessionId}`, { rootElement: '#right', location: 'none' });
5028
- Promise.all([player1, player2]).then(() => {
5029
- // Both apps have completed the initial render
5030
- $('#loading').fadeOut();
5031
- });
5032
- });
5033
- ```
5034
- Do note that each app instance maintains their own registry/container, so
5035
- they will run in complete isolation by default.
5036
- #### Server-Side Rendering (also known as FastBoot)
5037
- This setup allows you to run your Ember app in a server environment using
5038
- Node.js and render its content into static HTML for SEO purposes.
5039
- ```javascript
5040
- const HTMLSerializer = new SimpleDOM.HTMLSerializer(SimpleDOM.voidMap);
5041
- function renderURL(url) {
5042
- let dom = new SimpleDOM.Document();
5043
- let rootElement = dom.body;
5044
- let options = { isBrowser: false, document: dom, rootElement: rootElement };
5045
- return MyApp.visit(options).then(instance => {
5046
- try {
5047
- return HTMLSerializer.serialize(rootElement.firstChild);
5048
- } finally {
5049
- instance.destroy();
5050
- }
5051
- });
5052
- }
5053
- ```
5054
- In this scenario, because Ember does not have access to a global `document`
5055
- object in the Node.js environment, you must provide one explicitly. In practice,
5056
- in the non-browser environment, the stand-in `document` object only need to
5057
- implement a limited subset of the full DOM API. The `SimpleDOM` library is known
5058
- to work.
5059
- Since there is no access to jQuery in the non-browser environment, you must also
5060
- specify a DOM `Element` object in the same `document` for the `rootElement` option
5061
- (as opposed to a selector string like `"body"`).
5062
- See the documentation on the `isBrowser`, `document` and `rootElement` properties
5063
- on `Ember.ApplicationInstance.BootOptions` for details.
5064
- #### Server-Side Resource Discovery
5065
- This setup allows you to run the routing layer of your Ember app in a server
5066
- environment using Node.js and completely disable rendering. This allows you
5067
- to simulate and discover the resources (i.e. AJAX requests) needed to fufill
5068
- a given request and eagerly "push" these resources to the client.
5069
- ```app/initializers/network-service.js
5070
- import BrowserNetworkService from 'app/services/network/browser';
5071
- import NodeNetworkService from 'app/services/network/node';
5072
- // Inject a (hypothetical) service for abstracting all AJAX calls and use
5073
- // the appropiate implementaion on the client/server. This also allows the
5074
- // server to log all the AJAX calls made during a particular request and use
5075
- // that for resource-discovery purpose.
5076
- export function initialize(application) {
5077
- if (window) { // browser
5078
- application.register('service:network', BrowserNetworkService);
5079
- } else { // node
5080
- application.register('service:network', NodeNetworkService);
5081
- }
5082
- application.inject('route', 'network', 'service:network');
5083
- };
5084
- export default {
5085
- name: 'network-service',
5086
- initialize: initialize
5087
- };
5088
- ```
5089
- ```app/routes/post.js
5090
- import Ember from 'ember';
5091
- // An example of how the (hypothetical) service is used in routes.
5092
- export default Ember.Route.extend({
5093
- model(params) {
5094
- return this.network.fetch(`/api/posts/${params.post_id}.json`);
5095
- },
5096
- afterModel(post) {
5097
- if (post.isExternalContent) {
5098
- return this.network.fetch(`/api/external/?url=${post.externalURL}`);
5099
- } else {
5100
- return post;
5101
- }
5102
- }
5103
- });
5104
- ```
5105
- ```javascript
5106
- // Finally, put all the pieces together
5107
- function discoverResourcesFor(url) {
5108
- return MyApp.visit(url, { isBrowser: false, shouldRender: false }).then(instance => {
5109
- let networkService = instance.lookup('service:network');
5110
- return networkService.requests; // => { "/api/posts/123.json": "..." }
5111
- });
5112
- }
5113
- ```
5114
- @method visit
5115
- @param url {String} The initial URL to navigate to
5116
- @param options {Ember.ApplicationInstance.BootOptions}
5117
- @return {Promise<Ember.ApplicationInstance, Error>}
5118
- @private
5119
- */
5120
- enifed('ember-application/system/resolver', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/property_get', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/system/namespace', 'ember-htmlbars/helpers', 'ember-application/utils/validate-type', 'ember-metal/dictionary'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalProperty_get, _emberRuntimeSystemString, _emberRuntimeSystemObject, _emberRuntimeSystemNamespace, _emberHtmlbarsHelpers, _emberApplicationUtilsValidateType, _emberMetalDictionary) {
5370
+ // Force-assign these flags to their default values when the feature is
5371
+ // disabled, this ensures we can rely on their values in other paths.
5372
+ enifed('ember-application/system/resolver', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/system/namespace', 'ember-htmlbars/helpers', 'ember-application/utils/validate-type', 'ember-metal/dictionary', 'ember-htmlbars/template_registry'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberRuntimeSystemString, _emberRuntimeSystemObject, _emberRuntimeSystemNamespace, _emberHtmlbarsHelpers, _emberApplicationUtilsValidateType, _emberMetalDictionary, _emberHtmlbarsTemplate_registry) {
5121
5373
  /**
5122
5374
  @module ember
5123
5375
  @submodule ember-application
@@ -5398,14 +5650,7 @@ enifed('ember-application/system/resolver', ['exports', 'ember-metal/core', 'emb
5398
5650
  resolveTemplate: function (parsedName) {
5399
5651
  var templateName = parsedName.fullNameWithoutType.replace(/\./g, '/');
5400
5652
 
5401
- if (_emberMetalCore.default.TEMPLATES.hasOwnProperty(templateName)) {
5402
- return _emberMetalCore.default.TEMPLATES[templateName];
5403
- }
5404
-
5405
- templateName = _emberRuntimeSystemString.decamelize(templateName);
5406
- if (_emberMetalCore.default.TEMPLATES.hasOwnProperty(templateName)) {
5407
- return _emberMetalCore.default.TEMPLATES[templateName];
5408
- }
5653
+ return _emberHtmlbarsTemplate_registry.get(templateName) || _emberHtmlbarsTemplate_registry.get(_emberRuntimeSystemString.decamelize(templateName));
5409
5654
  },
5410
5655
 
5411
5656
  /**
@@ -6065,6 +6310,10 @@ enifed('ember-debug', ['exports', 'ember-metal/core', 'ember-metal/debug', 'embe
6065
6310
  _emberMetalFeatures.FEATURES['features-stripped-test'] = true;
6066
6311
  var featuresWereStripped = true;
6067
6312
 
6313
+ if (_emberMetalFeatures.default('features-stripped-test')) {
6314
+ exports.featuresWereStripped = featuresWereStripped = false;
6315
+ }
6316
+
6068
6317
  delete _emberMetalFeatures.FEATURES['features-stripped-test'];
6069
6318
  _warnIfUsingStrippedFeatureFlags(_emberMetalCore.default.ENV.FEATURES, featuresWereStripped);
6070
6319
 
@@ -6210,16 +6459,6 @@ enifed('ember-extension-support/container_debug_adapter', ['exports', 'ember-met
6210
6459
  @public
6211
6460
  */
6212
6461
  exports.default = _emberRuntimeSystemObject.default.extend({
6213
- /**
6214
- The container of the application being debugged.
6215
- This property will be injected
6216
- on creation.
6217
- @property container
6218
- @default null
6219
- @public
6220
- */
6221
- container: null,
6222
-
6223
6462
  /**
6224
6463
  The resolver instance of the application
6225
6464
  being debugged. This property will be injected
@@ -6277,7 +6516,7 @@ enifed('ember-extension-support/container_debug_adapter', ['exports', 'ember-met
6277
6516
  }
6278
6517
  });
6279
6518
  });
6280
- enifed('ember-extension-support/data_adapter', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-runtime/system/string', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/native_array', 'ember-application/system/application'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberRuntimeSystemString, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject, _emberRuntimeSystemNative_array, _emberApplicationSystemApplication) {
6519
+ enifed('ember-extension-support/data_adapter', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-runtime/system/string', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/native_array', 'ember-application/system/application', 'container/owner'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberRuntimeSystemString, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject, _emberRuntimeSystemNative_array, _emberApplicationSystemApplication, _containerOwner) {
6281
6520
  'use strict';
6282
6521
 
6283
6522
  /**
@@ -6333,17 +6572,6 @@ enifed('ember-extension-support/data_adapter', ['exports', 'ember-metal/property
6333
6572
  this.releaseMethods = _emberRuntimeSystemNative_array.A();
6334
6573
  },
6335
6574
 
6336
- /**
6337
- The container of the application being debugged.
6338
- This property will be injected
6339
- on creation.
6340
- @property container
6341
- @default null
6342
- @since 1.3.0
6343
- @public
6344
- */
6345
- container: null,
6346
-
6347
6575
  /**
6348
6576
  The container-debug-adapter which is used
6349
6577
  to list all models.
@@ -6437,7 +6665,7 @@ enifed('ember-extension-support/data_adapter', ['exports', 'ember-metal/property
6437
6665
 
6438
6666
  _nameToClass: function (type) {
6439
6667
  if (typeof type === 'string') {
6440
- type = this.container.lookupFactory('model:' + type);
6668
+ type = _containerOwner.getOwner(this)._lookupFactory('model:' + type);
6441
6669
  }
6442
6670
  return type;
6443
6671
  },
@@ -7844,7 +8072,7 @@ enifed("ember-htmlbars/hooks/cleanup-render-node", ["exports"], function (export
7844
8072
  }
7845
8073
  }
7846
8074
  });
7847
- enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember-htmlbars/node-managers/component-node-manager', 'ember-views/system/build-component-template', 'ember-htmlbars/utils/lookup-component', 'ember-metal/cache'], function (exports, _emberMetalDebug, _emberHtmlbarsNodeManagersComponentNodeManager, _emberViewsSystemBuildComponentTemplate, _emberHtmlbarsUtilsLookupComponent, _emberMetalCache) {
8075
+ enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember-htmlbars/node-managers/component-node-manager', 'ember-views/system/build-component-template', 'ember-htmlbars/utils/lookup-component', 'ember-metal/cache', 'ember-htmlbars/system/lookup-helper', 'ember-htmlbars/keywords/closure-component'], function (exports, _emberMetalDebug, _emberHtmlbarsNodeManagersComponentNodeManager, _emberViewsSystemBuildComponentTemplate, _emberHtmlbarsUtilsLookupComponent, _emberMetalCache, _emberHtmlbarsSystemLookupHelper, _emberHtmlbarsKeywordsClosureComponent) {
7848
8076
  'use strict';
7849
8077
 
7850
8078
  exports.default = componentHook;
@@ -7853,10 +8081,6 @@ enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember
7853
8081
  return key.match(/^(@?)<(.*)>$/);
7854
8082
  });
7855
8083
 
7856
- var CONTAINS_DASH = new _emberMetalCache.default(1000, function (key) {
7857
- return key.indexOf('-') !== -1;
7858
- });
7859
-
7860
8084
  function componentHook(renderNode, env, scope, _tagName, params, attrs, templates, visitor) {
7861
8085
  var state = renderNode.getState();
7862
8086
 
@@ -7867,6 +8091,15 @@ enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember
7867
8091
  }
7868
8092
 
7869
8093
  var tagName = _tagName;
8094
+ if (_emberHtmlbarsSystemLookupHelper.CONTAINS_DOT_CACHE.get(tagName)) {
8095
+ var stream = env.hooks.get(env, scope, tagName);
8096
+ var componentCell = stream.value();
8097
+ if (_emberHtmlbarsKeywordsClosureComponent.isComponentCell(componentCell)) {
8098
+ tagName = componentCell[_emberHtmlbarsKeywordsClosureComponent.COMPONENT_PATH];
8099
+ attrs = _emberHtmlbarsKeywordsClosureComponent.mergeInNewHash(componentCell[_emberHtmlbarsKeywordsClosureComponent.COMPONENT_HASH], attrs);
8100
+ }
8101
+ }
8102
+
7870
8103
  var isAngleBracket = false;
7871
8104
  var isTopLevel = false;
7872
8105
  var isDasherized = false;
@@ -7879,7 +8112,7 @@ enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember
7879
8112
  isTopLevel = !!angles[1];
7880
8113
  }
7881
8114
 
7882
- if (CONTAINS_DASH.get(tagName)) {
8115
+ if (_emberHtmlbarsSystemLookupHelper.CONTAINS_DASH_CACHE.get(tagName)) {
7883
8116
  isDasherized = true;
7884
8117
  }
7885
8118
 
@@ -7912,7 +8145,7 @@ enifed('ember-htmlbars/hooks/component', ['exports', 'ember-metal/debug', 'ember
7912
8145
  var component = undefined,
7913
8146
  layout = undefined;
7914
8147
  if (isDasherized || !isAngleBracket) {
7915
- var result = _emberHtmlbarsUtilsLookupComponent.default(env.container, tagName);
8148
+ var result = _emberHtmlbarsUtilsLookupComponent.default(env.owner, tagName);
7916
8149
  component = result.component;
7917
8150
  layout = result.layout;
7918
8151
 
@@ -8401,10 +8634,10 @@ enifed('ember-htmlbars/hooks/has-helper', ['exports', 'ember-htmlbars/system/loo
8401
8634
  return true;
8402
8635
  }
8403
8636
 
8404
- var container = env.container;
8405
- if (_emberHtmlbarsSystemLookupHelper.validateLazyHelperName(helperName, container, env.hooks.keywords)) {
8406
- var containerName = 'helper:' + helperName;
8407
- if (container.registry.has(containerName)) {
8637
+ var owner = env.owner;
8638
+ if (_emberHtmlbarsSystemLookupHelper.validateLazyHelperName(helperName, owner, env.hooks.keywords)) {
8639
+ var registrationName = 'helper:' + helperName;
8640
+ if (owner.hasRegistration(registrationName)) {
8408
8641
  return true;
8409
8642
  }
8410
8643
  }
@@ -8686,7 +8919,7 @@ enifed("ember-htmlbars/hooks/will-cleanup-tree", ["exports"], function (exports)
8686
8919
  view.ownerView._destroyingSubtreeForView = view;
8687
8920
  }
8688
8921
  });
8689
- enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/utils', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-htmlbars/hooks/subexpr', 'ember-metal/assign', 'ember-htmlbars/utils/extract-positional-params', 'ember-htmlbars/utils/lookup-component'], function (exports, _emberMetalUtils, _emberMetalStreamsStream, _emberMetalStreamsUtils, _emberHtmlbarsHooksSubexpr, _emberMetalAssign, _emberHtmlbarsUtilsExtractPositionalParams, _emberHtmlbarsUtilsLookupComponent) {
8922
+ enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/debug', 'ember-metal/is_none', 'ember-metal/symbol', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-htmlbars/hooks/subexpr', 'ember-metal/assign', 'ember-htmlbars/utils/extract-positional-params', 'ember-htmlbars/utils/lookup-component'], function (exports, _emberMetalDebug, _emberMetalIs_none, _emberMetalSymbol, _emberMetalStreamsStream, _emberMetalStreamsUtils, _emberHtmlbarsHooksSubexpr, _emberMetalAssign, _emberHtmlbarsUtilsExtractPositionalParams, _emberHtmlbarsUtilsLookupComponent) {
8690
8923
  /**
8691
8924
  @module ember
8692
8925
  @submodule ember-templates
@@ -8696,16 +8929,16 @@ enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/uti
8696
8929
 
8697
8930
  exports.default = closureComponent;
8698
8931
  exports.isComponentCell = isComponentCell;
8699
- exports.mergeHash = mergeHash;
8700
- var COMPONENT_REFERENCE = _emberMetalUtils.symbol('COMPONENT_REFERENCE');
8932
+ exports.mergeInNewHash = mergeInNewHash;
8933
+ var COMPONENT_REFERENCE = _emberMetalSymbol.default('COMPONENT_REFERENCE');
8701
8934
  exports.COMPONENT_REFERENCE = COMPONENT_REFERENCE;
8702
- var COMPONENT_CELL = _emberMetalUtils.symbol('COMPONENT_CELL');
8935
+ var COMPONENT_CELL = _emberMetalSymbol.default('COMPONENT_CELL');
8703
8936
  exports.COMPONENT_CELL = COMPONENT_CELL;
8704
- var COMPONENT_PATH = _emberMetalUtils.symbol('COMPONENT_PATH');
8937
+ var COMPONENT_PATH = _emberMetalSymbol.default('COMPONENT_PATH');
8705
8938
  exports.COMPONENT_PATH = COMPONENT_PATH;
8706
- var COMPONENT_POSITIONAL_PARAMS = _emberMetalUtils.symbol('COMPONENT_POSITIONAL_PARAMS');
8939
+ var COMPONENT_POSITIONAL_PARAMS = _emberMetalSymbol.default('COMPONENT_POSITIONAL_PARAMS');
8707
8940
  exports.COMPONENT_POSITIONAL_PARAMS = COMPONENT_POSITIONAL_PARAMS;
8708
- var COMPONENT_HASH = _emberMetalUtils.symbol('COMPONENT_HASH');
8941
+ var COMPONENT_HASH = _emberMetalSymbol.default('COMPONENT_HASH');
8709
8942
 
8710
8943
  exports.COMPONENT_HASH = COMPONENT_HASH;
8711
8944
  var ClosureComponentStream = _emberMetalStreamsStream.default.extend({
@@ -8718,7 +8951,7 @@ enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/uti
8718
8951
  this[COMPONENT_REFERENCE] = true;
8719
8952
  },
8720
8953
  compute: function () {
8721
- return createClosureComponentCell(this._env, this._path, this._params, this._hash);
8954
+ return createClosureComponentCell(this._env, this._path, this._params, this._hash, this.label);
8722
8955
  }
8723
8956
  });
8724
8957
 
@@ -8745,16 +8978,25 @@ enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/uti
8745
8978
  return s;
8746
8979
  }
8747
8980
 
8748
- function createClosureComponentCell(env, originalComponentPath, params, hash) {
8981
+ function createClosureComponentCell(env, originalComponentPath, params, hash, label) {
8749
8982
  var componentPath = _emberMetalStreamsUtils.read(originalComponentPath);
8750
8983
 
8984
+ _emberMetalDebug.assert('Component path cannot be null in ' + label, !_emberMetalIs_none.default(componentPath));
8985
+
8751
8986
  if (isComponentCell(componentPath)) {
8752
8987
  return createNestedClosureComponentCell(componentPath, params, hash);
8753
8988
  } else {
8989
+ _emberMetalDebug.assert('The component helper cannot be used without a valid component name. You used "' + componentPath + '" via ' + label, isValidComponentPath(env, componentPath));
8754
8990
  return createNewClosureComponentCell(env, componentPath, params, hash);
8755
8991
  }
8756
8992
  }
8757
8993
 
8994
+ function isValidComponentPath(env, path) {
8995
+ var result = _emberHtmlbarsUtilsLookupComponent.default(env.owner, path);
8996
+
8997
+ return !!(result.component || result.layout);
8998
+ }
8999
+
8758
9000
  function isComponentCell(component) {
8759
9001
  return component && component[COMPONENT_CELL];
8760
9002
  }
@@ -8767,13 +9009,13 @@ enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/uti
8767
9009
  // This needs to be done in each nesting level to avoid raising assertions
8768
9010
  _emberHtmlbarsUtilsExtractPositionalParams.processPositionalParams(null, positionalParams, params, hash);
8769
9011
 
8770
- return _ref = {}, _ref[COMPONENT_PATH] = componentCell[COMPONENT_PATH], _ref[COMPONENT_HASH] = mergeHash(componentCell[COMPONENT_HASH], hash), _ref[COMPONENT_POSITIONAL_PARAMS] = positionalParams, _ref[COMPONENT_CELL] = true, _ref;
9012
+ return _ref = {}, _ref[COMPONENT_PATH] = componentCell[COMPONENT_PATH], _ref[COMPONENT_HASH] = mergeInNewHash(componentCell[COMPONENT_HASH], hash), _ref[COMPONENT_POSITIONAL_PARAMS] = positionalParams, _ref[COMPONENT_CELL] = true, _ref;
8771
9013
  }
8772
9014
 
8773
9015
  function createNewClosureComponentCell(env, componentPath, params, hash) {
8774
9016
  var _ref2;
8775
9017
 
8776
- var positionalParams = getPositionalParams(env.container, componentPath);
9018
+ var positionalParams = getPositionalParams(env.owner, componentPath);
8777
9019
 
8778
9020
  // This needs to be done in each nesting level to avoid raising assertions
8779
9021
  _emberHtmlbarsUtilsExtractPositionalParams.processPositionalParams(null, positionalParams, params, hash);
@@ -8799,8 +9041,8 @@ enifed('ember-htmlbars/keywords/closure-component', ['exports', 'ember-metal/uti
8799
9041
  }
8800
9042
  }
8801
9043
 
8802
- function mergeHash(original, updates) {
8803
- return _emberMetalAssign.default(original, updates);
9044
+ function mergeInNewHash(original, updates) {
9045
+ return _emberMetalAssign.default({}, original, updates);
8804
9046
  }
8805
9047
  });
8806
9048
  enifed('ember-htmlbars/keywords/collection', ['exports', 'ember-views/streams/utils', 'ember-views/views/collection_view', 'ember-htmlbars/node-managers/view-node-manager', 'ember-metal/assign'], function (exports, _emberViewsStreamsUtils, _emberViewsViewsCollection_view, _emberHtmlbarsNodeManagersViewNodeManager, _emberMetalAssign) {
@@ -8941,7 +9183,7 @@ enifed('ember-htmlbars/keywords/collection', ['exports', 'ember-views/streams/ut
8941
9183
 
8942
9184
  return _emberMetalAssign.default({}, state, {
8943
9185
  parentView: env.view,
8944
- viewClassOrInstance: getView(read(params[0]), env.container)
9186
+ viewClassOrInstance: getView(read(params[0]), env.owner)
8945
9187
  });
8946
9188
  },
8947
9189
 
@@ -9043,6 +9285,29 @@ enifed('ember-htmlbars/keywords/component', ['exports', 'htmlbars-runtime/hooks'
9043
9285
  {{live-updating-chart}}
9044
9286
  ```
9045
9287
 
9288
+ ## Nested Usage
9289
+
9290
+ The `component` helper can be used to package a component path with initial attrs.
9291
+ The included attrs can then be merged during the final invocation.
9292
+
9293
+ For example, given a `person-form` component with the following template:
9294
+
9295
+ ```handlebars
9296
+ {{yield (hash
9297
+ nameInput=(component "input" value=model.name placeholder="First Name"))}}
9298
+ ```
9299
+
9300
+ The following snippet:
9301
+
9302
+ ```
9303
+ {{#person-form as |form|}}
9304
+ {{component form.nameInput placeholder="Username"}}
9305
+ {{/person-form}}
9306
+ ```
9307
+
9308
+ would output an input whose value is already bound to `model.name` and `placeholder`
9309
+ is "Username".
9310
+
9046
9311
  @method component
9047
9312
  @since 1.11.0
9048
9313
  @for Ember.Templates.helpers
@@ -9050,8 +9315,11 @@ enifed('ember-htmlbars/keywords/component', ['exports', 'htmlbars-runtime/hooks'
9050
9315
  */
9051
9316
 
9052
9317
  exports.default = function (morph, env, scope, params, hash, template, inverse, visitor) {
9053
- _htmlbarsRuntimeHooks.keyword('@element_component', morph, env, scope, params, hash, template, inverse, visitor);
9054
- return true;
9318
+ if (morph) {
9319
+ _htmlbarsRuntimeHooks.keyword('@element_component', morph, env, scope, params, hash, template, inverse, visitor);
9320
+ return true;
9321
+ }
9322
+ return _emberHtmlbarsKeywordsClosureComponent.default(env, params, hash);
9055
9323
  };
9056
9324
  });
9057
9325
  enifed('ember-htmlbars/keywords/debugger', ['exports', 'ember-metal/debug'], function (exports, _emberMetalDebug) {
@@ -9222,7 +9490,7 @@ enifed('ember-htmlbars/keywords/element-component', ['exports', 'ember-metal/ass
9222
9490
  // This needs to be done in each nesting level to avoid raising assertions
9223
9491
  _emberHtmlbarsUtilsExtractPositionalParams.processPositionalParams(null, positionalParams, params, hash);
9224
9492
  params = [];
9225
- hash = _emberHtmlbarsKeywordsClosureComponent.mergeHash(closureComponent[_emberHtmlbarsKeywordsClosureComponent.COMPONENT_HASH], hash);
9493
+ hash = _emberHtmlbarsKeywordsClosureComponent.mergeInNewHash(closureComponent[_emberHtmlbarsKeywordsClosureComponent.COMPONENT_HASH], hash);
9226
9494
  }
9227
9495
 
9228
9496
  var templates = { default: template, inverse: inverse };
@@ -9598,7 +9866,7 @@ enifed('ember-htmlbars/keywords/legacy-yield', ['exports', 'ember-metal/streams/
9598
9866
  return true;
9599
9867
  }
9600
9868
  });
9601
- enifed('ember-htmlbars/keywords/mut', ['exports', 'ember-metal/debug', 'ember-metal/utils', 'ember-metal/streams/proxy-stream', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-views/compat/attrs-proxy', 'ember-routing-htmlbars/keywords/closure-action'], function (exports, _emberMetalDebug, _emberMetalUtils, _emberMetalStreamsProxyStream, _emberMetalStreamsStream, _emberMetalStreamsUtils, _emberViewsCompatAttrsProxy, _emberRoutingHtmlbarsKeywordsClosureAction) {
9869
+ enifed('ember-htmlbars/keywords/mut', ['exports', 'ember-metal/debug', 'ember-metal/symbol', 'ember-metal/streams/proxy-stream', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-views/compat/attrs-proxy', 'ember-routing-htmlbars/keywords/closure-action'], function (exports, _emberMetalDebug, _emberMetalSymbol, _emberMetalStreamsProxyStream, _emberMetalStreamsStream, _emberMetalStreamsUtils, _emberViewsCompatAttrsProxy, _emberRoutingHtmlbarsKeywordsClosureAction) {
9602
9870
  /**
9603
9871
  @module ember
9604
9872
  @submodule ember-templates
@@ -9610,7 +9878,7 @@ enifed('ember-htmlbars/keywords/mut', ['exports', 'ember-metal/debug', 'ember-me
9610
9878
 
9611
9879
  exports.default = mut;
9612
9880
  exports.privateMut = privateMut;
9613
- var MUTABLE_REFERENCE = _emberMetalUtils.symbol('MUTABLE_REFERENCE');
9881
+ var MUTABLE_REFERENCE = _emberMetalSymbol.default('MUTABLE_REFERENCE');
9614
9882
 
9615
9883
  exports.MUTABLE_REFERENCE = MUTABLE_REFERENCE;
9616
9884
  var MutStream = _emberMetalStreamsProxyStream.default.extend((_ProxyStream$extend = {
@@ -9738,7 +10006,7 @@ enifed('ember-htmlbars/keywords/outlet', ['exports', 'ember-metal/debug', 'ember
9738
10006
 
9739
10007
  'use strict';
9740
10008
 
9741
- _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.2.1';
10009
+ _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.3.0-beta.1';
9742
10010
 
9743
10011
  /**
9744
10012
  The `{{outlet}}` helper lets you specify where a child routes will render in
@@ -9836,17 +10104,21 @@ enifed('ember-htmlbars/keywords/outlet', ['exports', 'ember-metal/debug', 'ember
9836
10104
  var parentView = env.view;
9837
10105
  var outletState = state.outletState;
9838
10106
  var toRender = outletState.render;
9839
- var namespace = env.container.lookup('application:main');
10107
+ var namespace = env.owner.lookup('application:main');
9840
10108
  var LOG_VIEW_LOOKUPS = _emberMetalProperty_get.get(namespace, 'LOG_VIEW_LOOKUPS');
9841
10109
 
9842
10110
  var ViewClass = outletState.render.ViewClass;
9843
10111
 
9844
10112
  if (!state.hasParentOutlet && !ViewClass) {
9845
- ViewClass = env.container.lookupFactory('view:toplevel');
10113
+ ViewClass = env.owner._lookupFactory('view:toplevel');
9846
10114
  }
9847
10115
 
9848
10116
  var Component;
9849
10117
 
10118
+ if (_emberMetalFeatures.default('ember-routing-routable-components')) {
10119
+ Component = outletState.render.Component;
10120
+ }
10121
+
9850
10122
  var options;
9851
10123
  var attrs = {};
9852
10124
  if (Component) {
@@ -10465,7 +10737,7 @@ enifed('ember-htmlbars/keywords/view', ['exports', 'ember-views/streams/utils',
10465
10737
  var targetObject = read(scope.getSelf());
10466
10738
  var viewClassOrInstance = state.viewClassOrInstance;
10467
10739
  if (!viewClassOrInstance) {
10468
- viewClassOrInstance = getView(read(params[0]), env.container);
10740
+ viewClassOrInstance = getView(read(params[0]), env.owner);
10469
10741
  }
10470
10742
 
10471
10743
  // if parentView exists, use its controller (the default
@@ -10532,17 +10804,17 @@ enifed('ember-htmlbars/keywords/view', ['exports', 'ember-views/streams/utils',
10532
10804
  }
10533
10805
  };
10534
10806
 
10535
- function getView(viewPath, container) {
10807
+ function getView(viewPath, owner) {
10536
10808
  var viewClassOrInstance;
10537
10809
 
10538
10810
  if (!viewPath) {
10539
- if (container) {
10540
- viewClassOrInstance = container.lookupFactory('view:toplevel');
10811
+ if (owner) {
10812
+ viewClassOrInstance = owner._lookupFactory('view:toplevel');
10541
10813
  } else {
10542
10814
  viewClassOrInstance = _emberViewsViewsView.default;
10543
10815
  }
10544
10816
  } else {
10545
- viewClassOrInstance = _emberViewsStreamsUtils.readViewFactory(viewPath, container);
10817
+ viewClassOrInstance = _emberViewsStreamsUtils.readViewFactory(viewPath, owner);
10546
10818
  }
10547
10819
 
10548
10820
  return viewClassOrInstance;
@@ -10743,14 +11015,14 @@ enifed('ember-htmlbars/morphs/morph', ['exports', 'dom-helper', 'ember-metal/deb
10743
11015
 
10744
11016
  exports.default = EmberMorph;
10745
11017
  });
10746
- enifed('ember-htmlbars/node-managers/component-node-manager', ['exports', 'ember-metal/debug', 'ember-views/system/build-component-template', 'ember-htmlbars/hooks/get-cell-or-value', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-views/compat/attrs-proxy', 'ember-htmlbars/system/instrumentation-support', 'ember-views/components/component', 'ember-htmlbars/glimmer-component', 'ember-htmlbars/utils/extract-positional-params', 'ember-metal/utils', 'ember-htmlbars/hooks/get-value'], function (exports, _emberMetalDebug, _emberViewsSystemBuildComponentTemplate, _emberHtmlbarsHooksGetCellOrValue, _emberMetalProperty_get, _emberMetalProperty_set, _emberViewsCompatAttrsProxy, _emberHtmlbarsSystemInstrumentationSupport, _emberViewsComponentsComponent, _emberHtmlbarsGlimmerComponent, _emberHtmlbarsUtilsExtractPositionalParams, _emberMetalUtils, _emberHtmlbarsHooksGetValue) {
11018
+ enifed('ember-htmlbars/node-managers/component-node-manager', ['exports', 'ember-metal/debug', 'ember-views/system/build-component-template', 'ember-htmlbars/hooks/get-cell-or-value', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-views/compat/attrs-proxy', 'ember-htmlbars/system/instrumentation-support', 'ember-views/components/component', 'ember-htmlbars/glimmer-component', 'ember-htmlbars/utils/extract-positional-params', 'ember-metal/symbol', 'container/owner', 'ember-htmlbars/hooks/get-value'], function (exports, _emberMetalDebug, _emberViewsSystemBuildComponentTemplate, _emberHtmlbarsHooksGetCellOrValue, _emberMetalProperty_get, _emberMetalProperty_set, _emberViewsCompatAttrsProxy, _emberHtmlbarsSystemInstrumentationSupport, _emberViewsComponentsComponent, _emberHtmlbarsGlimmerComponent, _emberHtmlbarsUtilsExtractPositionalParams, _emberMetalSymbol, _containerOwner, _emberHtmlbarsHooksGetValue) {
10747
11019
  'use strict';
10748
11020
 
10749
11021
  exports.createComponent = createComponent;
10750
11022
  exports.takeLegacySnapshot = takeLegacySnapshot;
10751
11023
 
10752
11024
  // These symbols will be used to limit link-to's public API surface area.
10753
- var HAS_BLOCK = _emberMetalUtils.symbol('HAS_BLOCK');
11025
+ var HAS_BLOCK = _emberMetalSymbol.default('HAS_BLOCK');
10754
11026
 
10755
11027
  exports.HAS_BLOCK = HAS_BLOCK;
10756
11028
  // In theory this should come through the env, but it should
@@ -10983,14 +11255,12 @@ enifed('ember-htmlbars/node-managers/component-node-manager', ['exports', 'ember
10983
11255
  props._isAngleBracket = true;
10984
11256
  }
10985
11257
 
10986
- props.renderer = props.parentView ? props.parentView.renderer : env.container.lookup('renderer:-dom');
10987
- props._viewRegistry = props.parentView ? props.parentView._viewRegistry : env.container.lookup('-view-registry:main');
11258
+ _containerOwner.setOwner(props, env.owner);
11259
+ props.renderer = props.parentView ? props.parentView.renderer : env.owner.lookup('renderer:-dom');
11260
+ props._viewRegistry = props.parentView ? props.parentView._viewRegistry : env.owner.lookup('-view-registry:main');
10988
11261
 
10989
11262
  var component = _component.create(props);
10990
11263
 
10991
- // for the fallback case
10992
- component.container = component.container || env.container;
10993
-
10994
11264
  if (props.parentView) {
10995
11265
  props.parentView.appendChild(component);
10996
11266
 
@@ -11055,7 +11325,7 @@ enifed('ember-htmlbars/node-managers/component-node-manager', ['exports', 'ember
11055
11325
  return env.childWithView(this.emberView);
11056
11326
  }
11057
11327
  });
11058
- enifed('ember-htmlbars/node-managers/view-node-manager', ['exports', 'ember-metal/assign', 'ember-metal/debug', 'ember-views/system/build-component-template', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/set_properties', 'ember-views/views/view', 'ember-views/compat/attrs-proxy', 'ember-htmlbars/hooks/get-cell-or-value', 'ember-htmlbars/system/instrumentation-support', 'ember-htmlbars/node-managers/component-node-manager', 'ember-htmlbars/hooks/get-value'], function (exports, _emberMetalAssign, _emberMetalDebug, _emberViewsSystemBuildComponentTemplate, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalSet_properties, _emberViewsViewsView, _emberViewsCompatAttrsProxy, _emberHtmlbarsHooksGetCellOrValue, _emberHtmlbarsSystemInstrumentationSupport, _emberHtmlbarsNodeManagersComponentNodeManager, _emberHtmlbarsHooksGetValue) {
11328
+ enifed('ember-htmlbars/node-managers/view-node-manager', ['exports', 'ember-metal/assign', 'ember-metal/debug', 'ember-views/system/build-component-template', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/set_properties', 'ember-views/views/view', 'ember-views/compat/attrs-proxy', 'ember-htmlbars/hooks/get-cell-or-value', 'ember-htmlbars/system/instrumentation-support', 'ember-htmlbars/node-managers/component-node-manager', 'container/owner', 'ember-htmlbars/hooks/get-value'], function (exports, _emberMetalAssign, _emberMetalDebug, _emberViewsSystemBuildComponentTemplate, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalSet_properties, _emberViewsViewsView, _emberViewsCompatAttrsProxy, _emberHtmlbarsHooksGetCellOrValue, _emberHtmlbarsSystemInstrumentationSupport, _emberHtmlbarsNodeManagersComponentNodeManager, _containerOwner, _emberHtmlbarsHooksGetValue) {
11059
11329
  'use strict';
11060
11330
 
11061
11331
  exports.createOrUpdateComponent = createOrUpdateComponent;
@@ -11234,9 +11504,12 @@ enifed('ember-htmlbars/node-managers/view-node-manager', ['exports', 'ember-meta
11234
11504
  }
11235
11505
 
11236
11506
  mergeBindings(props, snapshot);
11237
- props.container = options.parentView ? options.parentView.container : env.container;
11238
- props.renderer = options.parentView ? options.parentView.renderer : props.container && props.container.lookup('renderer:-dom');
11239
- props._viewRegistry = options.parentView ? options.parentView._viewRegistry : props.container && props.container.lookup('-view-registry:main');
11507
+
11508
+ var owner = options.parentView ? _containerOwner.getOwner(options.parentView) : env.owner;
11509
+
11510
+ _containerOwner.setOwner(props, owner);
11511
+ props.renderer = options.parentView ? options.parentView.renderer : owner && owner.lookup('renderer:-dom');
11512
+ props._viewRegistry = options.parentView ? options.parentView._viewRegistry : owner && owner.lookup('-view-registry:main');
11240
11513
 
11241
11514
  if (proto.controller !== defaultController || hasSuppliedController) {
11242
11515
  delete props._context;
@@ -11444,7 +11717,7 @@ enifed('ember-htmlbars/system/append-templated-view', ['exports', 'ember-metal/d
11444
11717
  return parentView.appendChild(viewClassOrInstance, props);
11445
11718
  }
11446
11719
  });
11447
- enifed('ember-htmlbars/system/bootstrap', ['exports', 'ember-metal/core', 'ember-views/component_lookup', 'ember-views/system/jquery', 'ember-metal/error', 'ember-runtime/system/lazy_load', 'ember-template-compiler/system/compile', 'ember-metal/environment'], function (exports, _emberMetalCore, _emberViewsComponent_lookup, _emberViewsSystemJquery, _emberMetalError, _emberRuntimeSystemLazy_load, _emberTemplateCompilerSystemCompile, _emberMetalEnvironment) {
11720
+ enifed('ember-htmlbars/system/bootstrap', ['exports', 'ember-views/component_lookup', 'ember-views/system/jquery', 'ember-metal/error', 'ember-runtime/system/lazy_load', 'ember-template-compiler/system/compile', 'ember-metal/environment', 'ember-htmlbars/template_registry'], function (exports, _emberViewsComponent_lookup, _emberViewsSystemJquery, _emberMetalError, _emberRuntimeSystemLazy_load, _emberTemplateCompilerSystemCompile, _emberMetalEnvironment, _emberHtmlbarsTemplate_registry) {
11448
11721
  /*globals Handlebars */
11449
11722
 
11450
11723
  /**
@@ -11498,12 +11771,12 @@ enifed('ember-htmlbars/system/bootstrap', ['exports', 'ember-metal/core', 'ember
11498
11771
  }
11499
11772
 
11500
11773
  // Check if template of same name already exists
11501
- if (_emberMetalCore.default.TEMPLATES[templateName] !== undefined) {
11774
+ if (_emberHtmlbarsTemplate_registry.has(templateName)) {
11502
11775
  throw new _emberMetalError.default('Template named "' + templateName + '" already exists.');
11503
11776
  }
11504
11777
 
11505
11778
  // For templates which have a name, we save them and then remove them from the DOM
11506
- _emberMetalCore.default.TEMPLATES[templateName] = template;
11779
+ _emberHtmlbarsTemplate_registry.set(templateName, template);
11507
11780
 
11508
11781
  // Remove script tag from DOM
11509
11782
  script.remove();
@@ -11634,6 +11907,11 @@ enifed('ember-htmlbars/system/lookup-helper', ['exports', 'ember-metal/debug', '
11634
11907
  });
11635
11908
 
11636
11909
  exports.CONTAINS_DASH_CACHE = CONTAINS_DASH_CACHE;
11910
+ var CONTAINS_DOT_CACHE = new _emberMetalCache.default(1000, function (key) {
11911
+ return key.indexOf('.') !== -1;
11912
+ });
11913
+
11914
+ exports.CONTAINS_DOT_CACHE = CONTAINS_DOT_CACHE;
11637
11915
 
11638
11916
  function validateLazyHelperName(helperName, container, keywords) {
11639
11917
  return container && !(helperName in keywords);
@@ -11658,11 +11936,11 @@ enifed('ember-htmlbars/system/lookup-helper', ['exports', 'ember-metal/debug', '
11658
11936
  var helper = env.helpers[name];
11659
11937
 
11660
11938
  if (!helper) {
11661
- var container = env.container;
11662
- if (validateLazyHelperName(name, container, env.hooks.keywords)) {
11939
+ var owner = env.owner;
11940
+ if (validateLazyHelperName(name, owner, env.hooks.keywords)) {
11663
11941
  var helperName = 'helper:' + name;
11664
- if (container.registry.has(helperName)) {
11665
- helper = container.lookupFactory(helperName);
11942
+ if (owner.hasRegistration(helperName)) {
11943
+ helper = owner._lookupFactory(helperName);
11666
11944
  _emberMetalDebug.assert('Expected to find an Ember.Helper with the name ' + helperName + ', but found an object of type ' + typeof helper + ' instead.', helper.isHelperFactory || helper.isHelperInstance);
11667
11945
  }
11668
11946
  }
@@ -11737,7 +12015,7 @@ enifed('ember-htmlbars/system/make_bound_helper', ['exports', 'ember-metal/debug
11737
12015
  return _emberHtmlbarsHelper.helper(fn);
11738
12016
  }
11739
12017
  });
11740
- enifed('ember-htmlbars/system/render-env', ['exports', 'ember-htmlbars/env', 'ember-metal-views/renderer'], function (exports, _emberHtmlbarsEnv, _emberMetalViewsRenderer) {
12018
+ enifed('ember-htmlbars/system/render-env', ['exports', 'ember-htmlbars/env', 'ember-metal-views/renderer', 'container/owner'], function (exports, _emberHtmlbarsEnv, _emberMetalViewsRenderer, _containerOwner) {
11741
12019
  'use strict';
11742
12020
 
11743
12021
  exports.default = RenderEnv;
@@ -11750,7 +12028,7 @@ enifed('ember-htmlbars/system/render-env', ['exports', 'ember-htmlbars/env', 'em
11750
12028
 
11751
12029
  this.view = options.view;
11752
12030
  this.outletState = options.outletState;
11753
- this.container = options.container;
12031
+ this.owner = options.owner;
11754
12032
  this.renderer = options.renderer;
11755
12033
  this.dom = options.dom;
11756
12034
 
@@ -11764,7 +12042,7 @@ enifed('ember-htmlbars/system/render-env', ['exports', 'ember-htmlbars/env', 'em
11764
12042
  return new RenderEnv({
11765
12043
  view: view,
11766
12044
  outletState: view.outletState,
11767
- container: view.container,
12045
+ owner: _containerOwner.getOwner(view),
11768
12046
  renderer: view.renderer,
11769
12047
  dom: view.renderer._dom
11770
12048
  });
@@ -11774,7 +12052,7 @@ enifed('ember-htmlbars/system/render-env', ['exports', 'ember-htmlbars/env', 'em
11774
12052
  return new RenderEnv({
11775
12053
  view: view,
11776
12054
  outletState: this.outletState,
11777
- container: this.container,
12055
+ owner: this.owner,
11778
12056
  renderer: this.renderer,
11779
12057
  dom: this.dom,
11780
12058
  lifecycleHooks: this.lifecycleHooks,
@@ -11790,7 +12068,7 @@ enifed('ember-htmlbars/system/render-env', ['exports', 'ember-htmlbars/env', 'em
11790
12068
  return new RenderEnv({
11791
12069
  view: this.view,
11792
12070
  outletState: outletState,
11793
- container: this.container,
12071
+ owner: this.owner,
11794
12072
  renderer: this.renderer,
11795
12073
  dom: this.dom,
11796
12074
  lifecycleHooks: this.lifecycleHooks,
@@ -11818,6 +12096,41 @@ enifed('ember-htmlbars/system/render-view', ['exports', 'ember-htmlbars/node-man
11818
12096
  nodeManager.render(env, {});
11819
12097
  }
11820
12098
  });
12099
+ enifed("ember-htmlbars/template_registry", ["exports"], function (exports) {
12100
+ // STATE within a module is frowned apon, this exists
12101
+ // to support Ember.TEMPLATES but shield ember internals from this legacy
12102
+ // global API
12103
+ "use strict";
12104
+
12105
+ exports.setTemplates = setTemplates;
12106
+ exports.getTemplates = getTemplates;
12107
+ exports.get = get;
12108
+ exports.has = has;
12109
+ exports.set = set;
12110
+ var TEMPLATES = {};
12111
+
12112
+ function setTemplates(templates) {
12113
+ TEMPLATES = templates;
12114
+ }
12115
+
12116
+ function getTemplates() {
12117
+ return TEMPLATES;
12118
+ }
12119
+
12120
+ function get(name) {
12121
+ if (TEMPLATES.hasOwnProperty(name)) {
12122
+ return TEMPLATES[name];
12123
+ }
12124
+ }
12125
+
12126
+ function has(name) {
12127
+ return TEMPLATES.hasOwnProperty(name);
12128
+ }
12129
+
12130
+ function set(name, template) {
12131
+ return TEMPLATES[name] = template;
12132
+ }
12133
+ });
11821
12134
  enifed("ember-htmlbars/templates/component", ["exports", "ember-template-compiler/system/template"], function (exports, _emberTemplateCompilerSystemTemplate) {
11822
12135
  "use strict";
11823
12136
 
@@ -12730,7 +13043,7 @@ enifed('ember-htmlbars/utils/extract-positional-params', ['exports', 'ember-meta
12730
13043
  }
12731
13044
  }
12732
13045
  });
12733
- enifed('ember-htmlbars/utils/is-component', ['exports', 'ember-htmlbars/system/lookup-helper'], function (exports, _emberHtmlbarsSystemLookupHelper) {
13046
+ enifed('ember-htmlbars/utils/is-component', ['exports', 'ember-htmlbars/system/lookup-helper', 'ember-htmlbars/keywords/closure-component', 'ember-metal/streams/utils'], function (exports, _emberHtmlbarsSystemLookupHelper, _emberHtmlbarsKeywordsClosureComponent, _emberMetalStreamsUtils) {
12734
13047
  /**
12735
13048
  @module ember
12736
13049
  @submodule ember-htmlbars
@@ -12746,14 +13059,25 @@ enifed('ember-htmlbars/utils/is-component', ['exports', 'ember-htmlbars/system/l
12746
13059
  */
12747
13060
 
12748
13061
  function isComponent(env, scope, path) {
12749
- var container = env.container;
12750
- if (!container) {
13062
+ var owner = env.owner;
13063
+ if (!owner) {
12751
13064
  return false;
12752
13065
  }
12753
- if (!_emberHtmlbarsSystemLookupHelper.CONTAINS_DASH_CACHE.get(path)) {
12754
- return false;
13066
+ if (typeof path === 'string') {
13067
+ if (_emberHtmlbarsSystemLookupHelper.CONTAINS_DOT_CACHE.get(path)) {
13068
+ var stream = env.hooks.get(env, scope, path);
13069
+ if (_emberMetalStreamsUtils.isStream(stream)) {
13070
+ var cell = stream.value();
13071
+ if (_emberHtmlbarsKeywordsClosureComponent.isComponentCell(cell)) {
13072
+ return true;
13073
+ }
13074
+ }
13075
+ }
13076
+ if (!_emberHtmlbarsSystemLookupHelper.CONTAINS_DASH_CACHE.get(path)) {
13077
+ return false;
13078
+ }
13079
+ return owner.hasRegistration('component:' + path) || owner.hasRegistration('template:components/' + path);
12755
13080
  }
12756
- return container.registry.has('component:' + path) || container.registry.has('template:components/' + path);
12757
13081
  }
12758
13082
  });
12759
13083
  enifed('ember-htmlbars/utils/lookup-component', ['exports'], function (exports) {
@@ -12890,7 +13214,7 @@ enifed('ember-htmlbars/utils/update-scope', ['exports', 'ember-metal/streams/pro
12890
13214
  }
12891
13215
  }
12892
13216
  });
12893
- enifed('ember-htmlbars', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler', 'ember-htmlbars/system/make_bound_helper', 'ember-htmlbars/helpers', 'ember-htmlbars/helpers/if_unless', 'ember-htmlbars/helpers/with', 'ember-htmlbars/helpers/loc', 'ember-htmlbars/helpers/log', 'ember-htmlbars/helpers/each', 'ember-htmlbars/helpers/each-in', 'ember-htmlbars/helpers/-normalize-class', 'ember-htmlbars/helpers/-concat', 'ember-htmlbars/helpers/-join-classes', 'ember-htmlbars/helpers/-legacy-each-with-controller', 'ember-htmlbars/helpers/-legacy-each-with-keyword', 'ember-htmlbars/helpers/-html-safe', 'ember-htmlbars/helpers/hash', 'ember-htmlbars/system/dom-helper', 'ember-htmlbars/helper', 'ember-htmlbars/glimmer-component', 'ember-htmlbars/system/bootstrap', 'ember-htmlbars/compat'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler, _emberHtmlbarsSystemMake_bound_helper, _emberHtmlbarsHelpers, _emberHtmlbarsHelpersIf_unless, _emberHtmlbarsHelpersWith, _emberHtmlbarsHelpersLoc, _emberHtmlbarsHelpersLog, _emberHtmlbarsHelpersEach, _emberHtmlbarsHelpersEachIn, _emberHtmlbarsHelpersNormalizeClass, _emberHtmlbarsHelpersConcat, _emberHtmlbarsHelpersJoinClasses, _emberHtmlbarsHelpersLegacyEachWithController, _emberHtmlbarsHelpersLegacyEachWithKeyword, _emberHtmlbarsHelpersHtmlSafe, _emberHtmlbarsHelpersHash, _emberHtmlbarsSystemDomHelper, _emberHtmlbarsHelper, _emberHtmlbarsGlimmerComponent, _emberHtmlbarsSystemBootstrap, _emberHtmlbarsCompat) {
13217
+ enifed('ember-htmlbars', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler', 'ember-htmlbars/system/make_bound_helper', 'ember-htmlbars/helpers', 'ember-htmlbars/helpers/if_unless', 'ember-htmlbars/helpers/with', 'ember-htmlbars/helpers/loc', 'ember-htmlbars/helpers/log', 'ember-htmlbars/helpers/each', 'ember-htmlbars/helpers/each-in', 'ember-htmlbars/helpers/-normalize-class', 'ember-htmlbars/helpers/-concat', 'ember-htmlbars/helpers/-join-classes', 'ember-htmlbars/helpers/-legacy-each-with-controller', 'ember-htmlbars/helpers/-legacy-each-with-keyword', 'ember-htmlbars/helpers/-html-safe', 'ember-htmlbars/helpers/hash', 'ember-htmlbars/system/dom-helper', 'ember-htmlbars/helper', 'ember-htmlbars/glimmer-component', 'ember-htmlbars/template_registry', 'ember-htmlbars/system/bootstrap', 'ember-htmlbars/compat'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler, _emberHtmlbarsSystemMake_bound_helper, _emberHtmlbarsHelpers, _emberHtmlbarsHelpersIf_unless, _emberHtmlbarsHelpersWith, _emberHtmlbarsHelpersLoc, _emberHtmlbarsHelpersLog, _emberHtmlbarsHelpersEach, _emberHtmlbarsHelpersEachIn, _emberHtmlbarsHelpersNormalizeClass, _emberHtmlbarsHelpersConcat, _emberHtmlbarsHelpersJoinClasses, _emberHtmlbarsHelpersLegacyEachWithController, _emberHtmlbarsHelpersLegacyEachWithKeyword, _emberHtmlbarsHelpersHtmlSafe, _emberHtmlbarsHelpersHash, _emberHtmlbarsSystemDomHelper, _emberHtmlbarsHelper, _emberHtmlbarsGlimmerComponent, _emberHtmlbarsTemplate_registry, _emberHtmlbarsSystemBootstrap, _emberHtmlbarsCompat) {
12894
13218
  /**
12895
13219
  Ember templates are executed by [HTMLBars](https://github.com/tildeio/htmlbars),
12896
13220
  an HTML-friendly version of [Handlebars](http://handlebarsjs.com/). Any valid Handlebars syntax is valid in an Ember template.
@@ -13001,6 +13325,8 @@ enifed('ember-htmlbars', ['exports', 'ember-metal/core', 'ember-metal/features',
13001
13325
  _emberHtmlbarsHelpers.registerHelper('-join-classes', _emberHtmlbarsHelpersJoinClasses.default);
13002
13326
  _emberHtmlbarsHelpers.registerHelper('-html-safe', _emberHtmlbarsHelpersHtmlSafe.default);
13003
13327
 
13328
+ _emberHtmlbarsHelpers.registerHelper('hash', _emberHtmlbarsHelpersHash.default);
13329
+
13004
13330
  if (_emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT) {
13005
13331
  _emberHtmlbarsHelpers.registerHelper('-legacy-each-with-controller', _emberHtmlbarsHelpersLegacyEachWithController.default);
13006
13332
  _emberHtmlbarsHelpers.registerHelper('-legacy-each-with-keyword', _emberHtmlbarsHelpersLegacyEachWithKeyword.default);
@@ -13015,8 +13341,28 @@ enifed('ember-htmlbars', ['exports', 'ember-metal/core', 'ember-metal/features',
13015
13341
  DOMHelper: _emberHtmlbarsSystemDomHelper.default
13016
13342
  };
13017
13343
 
13344
+ if (_emberMetalFeatures.default('ember-htmlbars-component-generation')) {
13345
+ _emberMetalCore.default.GlimmerComponent = _emberHtmlbarsGlimmerComponent.default;
13346
+ }
13347
+
13018
13348
  _emberHtmlbarsHelper.default.helper = _emberHtmlbarsHelper.helper;
13019
13349
  _emberMetalCore.default.Helper = _emberHtmlbarsHelper.default;
13350
+
13351
+ /**
13352
+ Global hash of shared templates. This will automatically be populated
13353
+ by the build tools so that you can store your Handlebars templates in
13354
+ separate files that get loaded into JavaScript at buildtime.
13355
+
13356
+ @property TEMPLATES
13357
+ @for Ember
13358
+ @type Object
13359
+ @private
13360
+ */
13361
+ Object.defineProperty(_emberMetalCore.default, 'TEMPLATES', {
13362
+ configurable: false,
13363
+ get: _emberHtmlbarsTemplate_registry.getTemplates,
13364
+ set: _emberHtmlbarsTemplate_registry.setTemplates
13365
+ });
13020
13366
  });
13021
13367
 
13022
13368
  // importing adds template bootstrapping
@@ -13798,7 +14144,7 @@ enifed('ember-metal/chains', ['exports', 'ember-metal/debug', 'ember-metal/prope
13798
14144
  return;
13799
14145
  }
13800
14146
 
13801
- var m = obj.__ember_meta__;
14147
+ var m = _emberMetalMeta.peekMeta(obj);
13802
14148
 
13803
14149
  if (!m || !m.readableChainWatchers()) {
13804
14150
  return;
@@ -13846,7 +14192,7 @@ enifed('ember-metal/chains', ['exports', 'ember-metal/debug', 'ember-metal/prope
13846
14192
  return;
13847
14193
  }
13848
14194
 
13849
- var meta = obj['__ember_meta__'];
14195
+ var meta = _emberMetalMeta.peekMeta(obj);
13850
14196
 
13851
14197
  // check if object meant only to be a prototype
13852
14198
  if (meta && meta.proto === obj) {
@@ -14052,7 +14398,7 @@ enifed('ember-metal/chains', ['exports', 'ember-metal/debug', 'ember-metal/prope
14052
14398
 
14053
14399
  function finishChains(obj) {
14054
14400
  // We only create meta if we really have to
14055
- var m = obj.__ember_meta__;
14401
+ var m = _emberMetalMeta.peekMeta(obj);
14056
14402
  if (m) {
14057
14403
  m = _emberMetalMeta.meta(obj);
14058
14404
 
@@ -14368,7 +14714,7 @@ enifed('ember-metal/computed', ['exports', 'ember-metal/debug', 'ember-metal/pro
14368
14714
  }
14369
14715
 
14370
14716
  // don't create objects just to invalidate
14371
- var meta = obj.__ember_meta__;
14717
+ var meta = _emberMetalMeta.peekMeta(obj);
14372
14718
  if (!meta || meta.source !== obj) {
14373
14719
  return;
14374
14720
  }
@@ -14592,22 +14938,20 @@ enifed('ember-metal/computed', ['exports', 'ember-metal/debug', 'ember-metal/pro
14592
14938
  computed property function. You can use this helper to define properties
14593
14939
  with mixins or via `Ember.defineProperty()`.
14594
14940
 
14595
- If you pass function as argument - it will be used as getter.
14596
- You can pass hash with two functions - instead of single function - as argument to provide both getter and setter.
14597
-
14598
- The `get` function should accept two parameters, `key` and `value`. If `value` is not
14599
- undefined you should set the `value` first. In either case return the
14600
- current value of the property.
14601
-
14602
- A computed property defined in this way might look like this:
14941
+ If you pass a function as an argument, it will be used as a getter. A computed
14942
+ property defined in this way might look like this:
14603
14943
 
14604
14944
  ```js
14605
14945
  let Person = Ember.Object.extend({
14606
- firstName: 'Betty',
14607
- lastName: 'Jones',
14946
+ init() {
14947
+ this._super(...arguments);
14948
+
14949
+ this.firstName = 'Betty';
14950
+ this.lastName = 'Jones';
14951
+ },
14608
14952
 
14609
14953
  fullName: Ember.computed('firstName', 'lastName', function() {
14610
- return this.get('firstName') + ' ' + this.get('lastName');
14954
+ return `${this.get('firstName')} ${this.get('lastName')}`;
14611
14955
  })
14612
14956
  });
14613
14957
 
@@ -14619,14 +14963,45 @@ enifed('ember-metal/computed', ['exports', 'ember-metal/debug', 'ember-metal/pro
14619
14963
  client.get('fullName'); // 'Betty Fuller'
14620
14964
  ```
14621
14965
 
14966
+ You can pass a hash with two functions, `get` and `set`, as an
14967
+ argument to provide both a getter and setter:
14968
+
14969
+ ```js
14970
+ let Person = Ember.Object.extend({
14971
+ init() {
14972
+ this._super(...arguments);
14973
+
14974
+ this.firstName = 'Betty';
14975
+ this.lastName = 'Jones';
14976
+ },
14977
+
14978
+ fullName: Ember.computed({
14979
+ get(key) {
14980
+ return `${this.get('firstName')} ${this.get('lastName')}`;
14981
+ },
14982
+ set(key, value) {
14983
+ let [firstName, lastName] = value.split(/\s+/);
14984
+ this.setProperties({ firstName, lastName });
14985
+ return value;
14986
+ }
14987
+ });
14988
+ })
14989
+
14990
+ let client = Person.create();
14991
+ client.get('firstName'); // 'Betty'
14992
+
14993
+ client.set('fullName', 'Carroll Fuller');
14994
+ client.get('firstName'); // 'Carroll'
14995
+ ```
14996
+
14997
+ The `set` function should accept two parameters, `key` and `value`. The value
14998
+ returned from `set` will be the new value of the property.
14999
+
14622
15000
  _Note: This is the preferred way to define computed properties when writing third-party
14623
15001
  libraries that depend on or use Ember, since there is no guarantee that the user
14624
- will have prototype extensions enabled._
15002
+ will have [prototype Extensions](http://emberjs.com/guides/configuring-ember/disabling-prototype-extensions/) enabled._
14625
15003
 
14626
- You might use this method if you disabled
14627
- [Prototype Extensions](http://emberjs.com/guides/configuring-ember/disabling-prototype-extensions/).
14628
- The alternative syntax might look like this
14629
- (if prototype extensions are enabled, which is the default behavior):
15004
+ The alternative syntax, with prototype extensions, might look like:
14630
15005
 
14631
15006
  ```js
14632
15007
  fullName() {
@@ -14676,7 +15051,7 @@ enifed('ember-metal/computed', ['exports', 'ember-metal/debug', 'ember-metal/pro
14676
15051
  @public
14677
15052
  */
14678
15053
  function cacheFor(obj, key) {
14679
- var meta = obj.__ember_meta__;
15054
+ var meta = _emberMetalMeta.peekMeta(obj);
14680
15055
  var cache = meta && meta.source === obj && meta.readableCache();
14681
15056
  var ret = cache && cache[key];
14682
15057
 
@@ -14710,7 +15085,7 @@ enifed('ember-metal/computed', ['exports', 'ember-metal/debug', 'ember-metal/pro
14710
15085
  exports.computed = computed;
14711
15086
  exports.cacheFor = cacheFor;
14712
15087
  });
14713
- enifed('ember-metal/computed_macros', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/computed', 'ember-metal/is_empty', 'ember-metal/is_none', 'ember-metal/alias'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalComputed, _emberMetalIs_empty, _emberMetalIs_none, _emberMetalAlias) {
15088
+ enifed('ember-metal/computed_macros', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/computed', 'ember-metal/is_empty', 'ember-metal/is_none', 'ember-metal/alias'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalComputed, _emberMetalIs_empty, _emberMetalIs_none, _emberMetalAlias) {
14714
15089
  'use strict';
14715
15090
 
14716
15091
  exports.empty = empty;
@@ -15216,47 +15591,6 @@ enifed('ember-metal/computed_macros', ['exports', 'ember-metal/core', 'ember-met
15216
15591
  });
15217
15592
 
15218
15593
  exports.or = or;
15219
- /**
15220
- A computed property that returns the array of values
15221
- for the provided dependent properties.
15222
-
15223
- Example
15224
-
15225
- ```javascript
15226
- var Hamster = Ember.Object.extend({
15227
- clothes: Ember.computed.collect('hat', 'shirt')
15228
- });
15229
-
15230
- var hamster = Hamster.create();
15231
-
15232
- hamster.get('clothes'); // [null, null]
15233
- hamster.set('hat', 'Camp Hat');
15234
- hamster.set('shirt', 'Camp Shirt');
15235
- hamster.get('clothes'); // ['Camp Hat', 'Camp Shirt']
15236
- ```
15237
-
15238
- @method collect
15239
- @for Ember.computed
15240
- @param {String} dependentKey*
15241
- @return {Ember.ComputedProperty} computed property which maps
15242
- values of all passed in properties to an array.
15243
- @public
15244
- */
15245
- var collect = generateComputedWithProperties(function (properties) {
15246
- var res = _emberMetalCore.default.A();
15247
- for (var key in properties) {
15248
- if (properties.hasOwnProperty(key)) {
15249
- if (_emberMetalIs_none.default(properties[key])) {
15250
- res.push(null);
15251
- } else {
15252
- res.push(properties[key]);
15253
- }
15254
- }
15255
- }
15256
- return res;
15257
- });
15258
-
15259
- exports.collect = collect;
15260
15594
  /**
15261
15595
  Creates a new property that is an alias for another property
15262
15596
  on an object. Calls to `get` or `set` this property behave as
@@ -15427,7 +15761,7 @@ enifed('ember-metal/core', ['exports'], function (exports) {
15427
15761
 
15428
15762
  @class Ember
15429
15763
  @static
15430
- @version 2.2.1
15764
+ @version 2.3.0-beta.1
15431
15765
  @public
15432
15766
  */
15433
15767
 
@@ -15471,11 +15805,11 @@ enifed('ember-metal/core', ['exports'], function (exports) {
15471
15805
 
15472
15806
  @property VERSION
15473
15807
  @type String
15474
- @default '2.2.1'
15808
+ @default '2.3.0-beta.1'
15475
15809
  @static
15476
15810
  @public
15477
15811
  */
15478
- Ember.VERSION = '2.2.1';
15812
+ Ember.VERSION = '2.3.0-beta.1';
15479
15813
 
15480
15814
  /**
15481
15815
  The hash of environment variables used to control various configuration
@@ -15930,7 +16264,7 @@ enifed('ember-metal/events', ['exports', 'ember-metal/debug', 'ember-metal/utils
15930
16264
  }
15931
16265
 
15932
16266
  function accumulateListeners(obj, eventName, otherActions) {
15933
- var meta = obj['__ember_meta__'];
16267
+ var meta = _emberMetalMeta.peekMeta(obj);
15934
16268
  if (!meta) {
15935
16269
  return;
15936
16270
  }
@@ -16090,7 +16424,7 @@ enifed('ember-metal/events', ['exports', 'ember-metal/debug', 'ember-metal/utils
16090
16424
 
16091
16425
  function sendEvent(obj, eventName, params, actions) {
16092
16426
  if (!actions) {
16093
- var meta = obj['__ember_meta__'];
16427
+ var meta = _emberMetalMeta.peekMeta(obj);
16094
16428
  actions = meta && meta.matchingListeners(eventName);
16095
16429
  }
16096
16430
 
@@ -16142,7 +16476,7 @@ enifed('ember-metal/events', ['exports', 'ember-metal/debug', 'ember-metal/utils
16142
16476
  */
16143
16477
 
16144
16478
  function hasListeners(obj, eventName) {
16145
- var meta = obj['__ember_meta__'];
16479
+ var meta = _emberMetalMeta.peekMeta(obj);
16146
16480
  if (!meta) {
16147
16481
  return false;
16148
16482
  }
@@ -16159,7 +16493,7 @@ enifed('ember-metal/events', ['exports', 'ember-metal/debug', 'ember-metal/utils
16159
16493
 
16160
16494
  function listenersFor(obj, eventName) {
16161
16495
  var ret = [];
16162
- var meta = obj['__ember_meta__'];
16496
+ var meta = _emberMetalMeta.peekMeta(obj);
16163
16497
  var actions = meta && meta.matchingListeners(eventName);
16164
16498
 
16165
16499
  if (!actions) {
@@ -16385,7 +16719,7 @@ enifed('ember-metal/get_properties', ['exports', 'ember-metal/property_get'], fu
16385
16719
  return ret;
16386
16720
  }
16387
16721
  });
16388
- enifed('ember-metal/injected_property', ['exports', 'ember-metal/debug', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/properties'], function (exports, _emberMetalDebug, _emberMetalComputed, _emberMetalAlias, _emberMetalProperties) {
16722
+ enifed('ember-metal/injected_property', ['exports', 'ember-metal/debug', 'ember-metal/computed', 'ember-metal/alias', 'ember-metal/properties', 'container/owner'], function (exports, _emberMetalDebug, _emberMetalComputed, _emberMetalAlias, _emberMetalProperties, _containerOwner) {
16389
16723
  'use strict';
16390
16724
 
16391
16725
  /**
@@ -16409,11 +16743,12 @@ enifed('ember-metal/injected_property', ['exports', 'ember-metal/debug', 'ember-
16409
16743
 
16410
16744
  function injectedPropertyGet(keyName) {
16411
16745
  var desc = this[keyName];
16746
+ var owner = _containerOwner.getOwner(this);
16412
16747
 
16413
16748
  _emberMetalDebug.assert('InjectedProperties should be defined with the Ember.inject computed property macros.', desc && desc.isDescriptor && desc.type);
16414
- _emberMetalDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', this.container);
16749
+ _emberMetalDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', owner);
16415
16750
 
16416
- return this.container.lookup(desc.type + ':' + (desc.name || keyName));
16751
+ return owner.lookup(desc.type + ':' + (desc.name || keyName));
16417
16752
  }
16418
16753
 
16419
16754
  InjectedProperty.prototype = Object.create(_emberMetalProperties.Descriptor.prototype);
@@ -16736,6 +17071,8 @@ enifed('ember-metal/is_empty', ['exports', 'ember-metal/property_get', 'ember-me
16736
17071
  Ember.isEmpty({}); // false
16737
17072
  Ember.isEmpty('Adam Hawkins'); // false
16738
17073
  Ember.isEmpty([0,1,2]); // false
17074
+ Ember.isEmpty('\n\t'); // false
17075
+ Ember.isEmpty(' '); // false
16739
17076
  ```
16740
17077
 
16741
17078
  @method isEmpty
@@ -16902,6 +17239,12 @@ enifed('ember-metal/libraries', ['exports', 'ember-metal/debug', 'ember-metal/fe
16902
17239
  }
16903
17240
  };
16904
17241
 
17242
+ if (_emberMetalFeatures.default('ember-libraries-isregistered')) {
17243
+ Libraries.prototype.isRegistered = function (name) {
17244
+ return !!this._getLibraryByName(name);
17245
+ };
17246
+ }
17247
+
16905
17248
  exports.default = Libraries;
16906
17249
  });
16907
17250
  enifed('ember-metal/logger', ['exports', 'ember-metal/core', 'ember-metal/error'], function (exports, _emberMetalCore, _emberMetalError) {
@@ -17573,6 +17916,9 @@ enifed('ember-metal/merge', ['exports', 'ember-metal/debug', 'ember-metal/featur
17573
17916
  */
17574
17917
 
17575
17918
  function merge(original, updates) {
17919
+ if (_emberMetalFeatures.default('ember-metal-ember-assign')) {
17920
+ _emberMetalDebug.deprecate('Usage of `Ember.merge` is deprecated, use `Ember.assign` instead.', false, { id: 'ember-metal.merge', until: '3.0.0' });
17921
+ }
17576
17922
 
17577
17923
  if (!updates || typeof updates !== 'object') {
17578
17924
  return original;
@@ -17596,6 +17942,8 @@ enifed('ember-metal/meta', ['exports', 'ember-metal/meta_listeners', 'ember-meta
17596
17942
  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
17597
17943
 
17598
17944
  exports.meta = meta;
17945
+ exports.peekMeta = peekMeta;
17946
+ exports.deleteMeta = deleteMeta;
17599
17947
 
17600
17948
  /**
17601
17949
  @module ember-metal
@@ -17634,6 +17982,7 @@ enifed('ember-metal/meta', ['exports', 'ember-metal/meta_listeners', 'ember-meta
17634
17982
  };
17635
17983
 
17636
17984
  var memberNames = Object.keys(members);
17985
+ var META_FIELD = '__ember_meta__';
17637
17986
 
17638
17987
  function Meta(obj, parentMeta) {
17639
17988
  this._cache = undefined;
@@ -17892,14 +18241,25 @@ enifed('ember-metal/meta', ['exports', 'ember-metal/meta_listeners', 'ember-meta
17892
18241
 
17893
18242
  exports.META_DESC = META_DESC;
17894
18243
  var EMBER_META_PROPERTY = {
17895
- name: '__ember_meta__',
18244
+ name: META_FIELD,
17896
18245
  descriptor: META_DESC
17897
18246
  };
17898
18247
 
17899
- // Placeholder for non-writable metas.
17900
- var EMPTY_META = new Meta(null);
18248
+ // choose the one appropriate for given platform
18249
+ var setMeta = function (obj, meta) {
18250
+ // if `null` already, just set it to the new value
18251
+ // otherwise define property first
18252
+ if (obj[META_FIELD] !== null) {
18253
+ if (obj.__defineNonEnumerable) {
18254
+ obj.__defineNonEnumerable(EMBER_META_PROPERTY);
18255
+ } else {
18256
+ Object.defineProperty(obj, META_FIELD, META_DESC);
18257
+ }
18258
+ }
18259
+
18260
+ obj[META_FIELD] = meta;
18261
+ };
17901
18262
 
17902
- exports.EMPTY_META = EMPTY_META;
17903
18263
  /**
17904
18264
  Retrieves the meta hash for an object. If `writable` is true ensures the
17905
18265
  hash is writable for this object as well.
@@ -17919,34 +18279,32 @@ enifed('ember-metal/meta', ['exports', 'ember-metal/meta_listeners', 'ember-meta
17919
18279
  @return {Object} the meta hash for an object
17920
18280
  */
17921
18281
 
17922
- function meta(obj, writable) {
17923
- var ret = obj.__ember_meta__;
17924
- if (writable === false) {
17925
- return ret || EMPTY_META;
17926
- }
18282
+ function meta(obj) {
18283
+ var maybeMeta = peekMeta(obj);
18284
+ var parent = undefined;
17927
18285
 
17928
- if (ret && ret.source === obj) {
17929
- return ret;
18286
+ // remove this code, in-favor of explicit parent
18287
+ if (maybeMeta) {
18288
+ if (maybeMeta.source === obj) {
18289
+ return maybeMeta;
18290
+ }
18291
+ parent = maybeMeta;
17930
18292
  }
17931
18293
 
17932
- if (!ret) {
17933
- ret = new Meta(obj);
17934
- } else {
17935
- ret = new Meta(obj, ret);
17936
- }
18294
+ var newMeta = new Meta(obj, parent);
18295
+ setMeta(obj, newMeta);
18296
+ return newMeta;
18297
+ }
17937
18298
 
17938
- // if `null` already, just set it to the new value
17939
- // otherwise define property first
17940
- if (obj.__ember_meta__ !== null) {
17941
- if (obj.__defineNonEnumerable) {
17942
- obj.__defineNonEnumerable(EMBER_META_PROPERTY);
17943
- } else {
17944
- Object.defineProperty(obj, '__ember_meta__', META_DESC);
17945
- }
17946
- }
17947
- obj.__ember_meta__ = ret;
18299
+ function peekMeta(obj) {
18300
+ return obj[META_FIELD];
18301
+ }
17948
18302
 
17949
- return ret;
18303
+ function deleteMeta(obj) {
18304
+ if (typeof obj[META_FIELD] !== 'object') {
18305
+ return;
18306
+ }
18307
+ obj[META_FIELD] = null;
17950
18308
  }
17951
18309
  });
17952
18310
  enifed('ember-metal/meta_listeners', ['exports'], function (exports) {
@@ -18131,7 +18489,6 @@ enifed('ember-metal/mixin', ['exports', 'ember-metal/core', 'ember-metal/error',
18131
18489
  @module ember
18132
18490
  @submodule ember-metal
18133
18491
  */
18134
-
18135
18492
  exports.mixin = mixin;
18136
18493
  exports.default = Mixin;
18137
18494
  exports.required = required;
@@ -18621,6 +18978,10 @@ enifed('ember-metal/mixin', ['exports', 'ember-metal/core', 'ember-metal/error',
18621
18978
  this.mixins = undefined;
18622
18979
  }
18623
18980
  this.ownerConstructor = undefined;
18981
+ this._without = undefined;
18982
+ this[_emberMetalUtils.GUID_KEY] = null;
18983
+ this[_emberMetalUtils.GUID_KEY + '_name'] = null;
18984
+ _emberMetalDebug.debugSeal(this);
18624
18985
  }
18625
18986
 
18626
18987
  Mixin._apply = applyMixin;
@@ -18737,7 +19098,7 @@ enifed('ember-metal/mixin', ['exports', 'ember-metal/core', 'ember-metal/error',
18737
19098
  if (obj instanceof Mixin) {
18738
19099
  return _detect(obj, this, {});
18739
19100
  }
18740
- var m = obj.__ember_meta__;
19101
+ var m = _emberMetalMeta.peekMeta(obj);
18741
19102
  if (!m) {
18742
19103
  return false;
18743
19104
  }
@@ -18788,10 +19149,12 @@ enifed('ember-metal/mixin', ['exports', 'ember-metal/core', 'ember-metal/error',
18788
19149
  return ret;
18789
19150
  };
18790
19151
 
19152
+ _emberMetalDebug.debugSeal(MixinPrototype);
19153
+
18791
19154
  // returns the mixins currently applied to the specified object
18792
19155
  // TODO: Make Ember.mixin
18793
19156
  Mixin.mixins = function (obj) {
18794
- var m = obj['__ember_meta__'];
19157
+ var m = _emberMetalMeta.peekMeta(obj);
18795
19158
  var ret = [];
18796
19159
  if (!m) {
18797
19160
  return ret;
@@ -18882,7 +19245,7 @@ enifed('ember-metal/mixin', ['exports', 'ember-metal/core', 'ember-metal/error',
18882
19245
  @param {String} propertyNames*
18883
19246
  @param {Function} func
18884
19247
  @return func
18885
- @private
19248
+ @public
18886
19249
  */
18887
19250
 
18888
19251
  function observer() {
@@ -19391,10 +19754,10 @@ enifed('ember-metal/properties', ['exports', 'ember-metal/debug', 'ember-metal/f
19391
19754
  return this;
19392
19755
  }
19393
19756
  });
19394
- enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-metal/events', 'ember-metal/observer_set'], function (exports, _emberMetalUtils, _emberMetalEvents, _emberMetalObserver_set) {
19757
+ enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/events', 'ember-metal/observer_set', 'ember-metal/symbol'], function (exports, _emberMetalUtils, _emberMetalMeta, _emberMetalEvents, _emberMetalObserver_set, _emberMetalSymbol) {
19395
19758
  'use strict';
19396
19759
 
19397
- var PROPERTY_DID_CHANGE = _emberMetalUtils.symbol('PROPERTY_DID_CHANGE');
19760
+ var PROPERTY_DID_CHANGE = _emberMetalSymbol.default('PROPERTY_DID_CHANGE');
19398
19761
 
19399
19762
  exports.PROPERTY_DID_CHANGE = PROPERTY_DID_CHANGE;
19400
19763
  var beforeObserverSet = new _emberMetalObserver_set.default();
@@ -19422,7 +19785,7 @@ enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-me
19422
19785
  @private
19423
19786
  */
19424
19787
  function propertyWillChange(obj, keyName) {
19425
- var m = obj['__ember_meta__'];
19788
+ var m = _emberMetalMeta.peekMeta(obj);
19426
19789
  var watching = m && m.peekWatching(keyName) > 0 || keyName === 'length';
19427
19790
  var proto = m && m.proto;
19428
19791
  var possibleDesc = obj[keyName];
@@ -19462,7 +19825,7 @@ enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-me
19462
19825
  @private
19463
19826
  */
19464
19827
  function propertyDidChange(obj, keyName) {
19465
- var m = obj['__ember_meta__'];
19828
+ var m = _emberMetalMeta.peekMeta(obj);
19466
19829
  var watching = m && m.peekWatching(keyName) > 0 || keyName === 'length';
19467
19830
  var proto = m && m.proto;
19468
19831
  var possibleDesc = obj[keyName];
@@ -19674,7 +20037,7 @@ enifed('ember-metal/property_events', ['exports', 'ember-metal/utils', 'ember-me
19674
20037
  exports.endPropertyChanges = endPropertyChanges;
19675
20038
  exports.changeProperties = changeProperties;
19676
20039
  });
19677
- enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/path_cache'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalPath_cache) {
20040
+ enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/meta'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalPath_cache, _emberMetalMeta) {
19678
20041
  /**
19679
20042
  @module ember-metal
19680
20043
  */
@@ -19732,9 +20095,9 @@ enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/
19732
20095
  return obj;
19733
20096
  }
19734
20097
 
19735
- var meta = obj['__ember_meta__'];
19736
- var possibleDesc = obj[keyName];
19737
- var desc = possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor ? possibleDesc : undefined;
20098
+ var meta = _emberMetalMeta.peekMeta(obj);
20099
+ var value = obj[keyName];
20100
+ var desc = value !== null && typeof value === 'object' && value.isDescriptor ? value : undefined;
19738
20101
  var ret;
19739
20102
 
19740
20103
  if (desc === undefined && _emberMetalPath_cache.isPath(keyName)) {
@@ -19747,7 +20110,7 @@ enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/
19747
20110
  if (meta && meta.peekWatching(keyName) > 0) {
19748
20111
  ret = meta.peekValues(keyName);
19749
20112
  } else {
19750
- ret = obj[keyName];
20113
+ ret = value;
19751
20114
  }
19752
20115
 
19753
20116
  if (ret === undefined && 'object' === typeof obj && !(keyName in obj) && 'function' === typeof obj.unknownProperty) {
@@ -19831,6 +20194,23 @@ enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/
19831
20194
  return root;
19832
20195
  }
19833
20196
 
20197
+ /**
20198
+ Retrieves the value of a property from an Object, or a default value in the
20199
+ case that the property returns `undefined`.
20200
+
20201
+ ```javascript
20202
+ Ember.getWithDefault(person, 'lastName', 'Doe');
20203
+ ```
20204
+
20205
+ @method getWithDefault
20206
+ @for Ember
20207
+ @param {Object} obj The object to retrieve from.
20208
+ @param {String} keyName The name of the property to retrieve
20209
+ @param {Object} defaultValue The value to return if the property value is undefined
20210
+ @return {Object} The property value or the defaultValue.
20211
+ @public
20212
+ */
20213
+
19834
20214
  function getWithDefault(root, key, defaultValue) {
19835
20215
  var value = get(root, key);
19836
20216
 
@@ -19842,7 +20222,7 @@ enifed('ember-metal/property_get', ['exports', 'ember-metal/core', 'ember-metal/
19842
20222
 
19843
20223
  exports.default = get;
19844
20224
  });
19845
- enifed('ember-metal/property_set', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/error', 'ember-metal/path_cache'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_events, _emberMetalProperties, _emberMetalError, _emberMetalPath_cache) {
20225
+ enifed('ember-metal/property_set', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/error', 'ember-metal/path_cache', 'ember-metal/meta'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_events, _emberMetalProperties, _emberMetalError, _emberMetalPath_cache, _emberMetalMeta) {
19846
20226
  'use strict';
19847
20227
 
19848
20228
  exports.set = set;
@@ -19871,7 +20251,7 @@ enifed('ember-metal/property_set', ['exports', 'ember-metal/debug', 'ember-metal
19871
20251
 
19872
20252
  var meta, possibleDesc, desc;
19873
20253
  if (obj) {
19874
- meta = obj['__ember_meta__'];
20254
+ meta = _emberMetalMeta.peekMeta(obj);
19875
20255
  possibleDesc = obj[keyName];
19876
20256
  desc = possibleDesc !== null && typeof possibleDesc === 'object' && possibleDesc.isDescriptor ? possibleDesc : undefined;
19877
20257
  }
@@ -20839,7 +21219,11 @@ enifed('ember-metal/streams/dependency', ['exports', 'ember-metal/debug', 'ember
20839
21219
  enifed('ember-metal/streams/key-stream', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/observer', 'ember-metal/streams/stream', 'ember-metal/streams/utils'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalObserver, _emberMetalStreamsStream, _emberMetalStreamsUtils) {
20840
21220
  'use strict';
20841
21221
 
20842
- var KeyStream = _emberMetalStreamsStream.default.extend({
21222
+ function labelFor(source, key) {
21223
+ return source.label ? source.label + '.' + key : key;
21224
+ }
21225
+
21226
+ exports.default = _emberMetalStreamsStream.default.extend({
20843
21227
  init: function (source, key) {
20844
21228
  _emberMetalDebug.assert('KeyStream error: source must be a stream', _emberMetalStreamsUtils.isStream(source)); // TODO: This isn't necessary.
20845
21229
  _emberMetalDebug.assert('KeyStream error: key must be a non-empty string', typeof key === 'string' && key.length > 0);
@@ -20856,9 +21240,17 @@ enifed('ember-metal/streams/key-stream', ['exports', 'ember-metal/debug', 'ember
20856
21240
 
20857
21241
  compute: function () {
20858
21242
  var object = this.sourceDep.getValue();
20859
- if (object) {
21243
+ var type = typeof object;
21244
+
21245
+ if (!object || type === 'boolean') {
21246
+ return;
21247
+ }
21248
+
21249
+ if (type === 'object') {
20860
21250
  return _emberMetalProperty_get.get(object, this.key);
20861
21251
  }
21252
+
21253
+ return object[this.key];
20862
21254
  },
20863
21255
 
20864
21256
  setValue: function (value) {
@@ -20903,12 +21295,6 @@ enifed('ember-metal/streams/key-stream', ['exports', 'ember-metal/debug', 'ember
20903
21295
  this._clearObservedObject();
20904
21296
  }
20905
21297
  });
20906
-
20907
- function labelFor(source, key) {
20908
- return source.label ? source.label + '.' + key : key;
20909
- }
20910
-
20911
- exports.default = KeyStream;
20912
21298
  });
20913
21299
  enifed('ember-metal/streams/proxy-stream', ['exports', 'ember-runtime/system/object', 'ember-metal/streams/stream'], function (exports, _emberRuntimeSystemObject, _emberMetalStreamsStream) {
20914
21300
  'use strict';
@@ -20942,7 +21328,7 @@ enifed('ember-metal/streams/proxy-stream', ['exports', 'ember-runtime/system/obj
20942
21328
 
20943
21329
  exports.default = ProxyStream;
20944
21330
  });
20945
- enifed('ember-metal/streams/stream', ['exports', 'ember-metal/core', 'ember-metal/assign', 'ember-metal/debug', 'ember-metal/path_cache', 'ember-metal/observer', 'ember-metal/streams/utils', 'ember-metal/empty_object', 'ember-metal/streams/subscriber', 'ember-metal/streams/dependency', 'ember-metal/utils'], function (exports, _emberMetalCore, _emberMetalAssign, _emberMetalDebug, _emberMetalPath_cache, _emberMetalObserver, _emberMetalStreamsUtils, _emberMetalEmpty_object, _emberMetalStreamsSubscriber, _emberMetalStreamsDependency, _emberMetalUtils) {
21331
+ enifed('ember-metal/streams/stream', ['exports', 'ember-metal/assign', 'ember-metal/debug', 'ember-metal/path_cache', 'ember-metal/observer', 'ember-metal/streams/utils', 'ember-metal/empty_object', 'ember-metal/streams/subscriber', 'ember-metal/streams/dependency', 'ember-metal/utils', 'require'], function (exports, _emberMetalAssign, _emberMetalDebug, _emberMetalPath_cache, _emberMetalObserver, _emberMetalStreamsUtils, _emberMetalEmpty_object, _emberMetalStreamsSubscriber, _emberMetalStreamsDependency, _emberMetalUtils, _require) {
20946
21332
  'use strict';
20947
21333
 
20948
21334
  exports.wrap = wrap;
@@ -20984,7 +21370,7 @@ enifed('ember-metal/streams/stream', ['exports', 'ember-metal/core', 'ember-meta
20984
21370
  },
20985
21371
 
20986
21372
  _makeChildStream: function (key) {
20987
- KeyStream = KeyStream || _emberMetalCore.default.__loader.require('ember-metal/streams/key-stream').default;
21373
+ KeyStream = KeyStream || _require.default('ember-metal/streams/key-stream').default;
20988
21374
  return new KeyStream(this, key);
20989
21375
  },
20990
21376
 
@@ -21124,7 +21510,7 @@ enifed('ember-metal/streams/stream', ['exports', 'ember-metal/core', 'ember-meta
21124
21510
  if (value !== this.observedProxy) {
21125
21511
  this._clearObservedProxy();
21126
21512
 
21127
- ProxyMixin = ProxyMixin || _emberMetalCore.default.__loader.require('ember-runtime/mixins/-proxy').default;
21513
+ ProxyMixin = ProxyMixin || _require.default('ember-runtime/mixins/-proxy').default;
21128
21514
 
21129
21515
  if (ProxyMixin.detect(value)) {
21130
21516
  _emberMetalObserver.addObserver(value, 'content', this, this.notify);
@@ -21719,8 +22105,18 @@ enifed('ember-metal/streams/utils', ['exports', 'ember-metal/debug', 'ember-meta
21719
22105
  }
21720
22106
  }
21721
22107
  });
21722
- enifed("ember-metal/symbol", ["exports"], function (exports) {
21723
- "use strict";
22108
+ enifed('ember-metal/symbol', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
22109
+ 'use strict';
22110
+
22111
+ exports.default = symbol;
22112
+
22113
+ function symbol(debugName) {
22114
+ // TODO: Investigate using platform symbols, but we do not
22115
+ // want to require non-enumerability for this API, which
22116
+ // would introduce a large cost.
22117
+
22118
+ return _emberMetalUtils.intern(debugName + ' [id=' + _emberMetalUtils.GUID_KEY + Math.floor(Math.random() * new Date()) + ']');
22119
+ }
21724
22120
  });
21725
22121
  enifed('ember-metal/utils', ['exports'], function (exports) {
21726
22122
  'no use strict';
@@ -21739,7 +22135,7 @@ enifed('ember-metal/utils', ['exports'], function (exports) {
21739
22135
  @return {Number} the uuid
21740
22136
  */
21741
22137
  exports.uuid = uuid;
21742
- exports.symbol = symbol;
22138
+ exports.intern = intern;
21743
22139
  exports.generateGuid = generateGuid;
21744
22140
  exports.guidFor = guidFor;
21745
22141
  exports.wrap = wrap;
@@ -21816,6 +22212,7 @@ enifed('ember-metal/utils', ['exports'], function (exports) {
21816
22212
  @private
21817
22213
  @return {String} interned version of the provided string
21818
22214
  */
22215
+
21819
22216
  function intern(str) {
21820
22217
  var obj = {};
21821
22218
  obj[str] = 1;
@@ -21827,14 +22224,6 @@ enifed('ember-metal/utils', ['exports'], function (exports) {
21827
22224
  return str;
21828
22225
  }
21829
22226
 
21830
- function symbol(debugName) {
21831
- // TODO: Investigate using platform symbols, but we do not
21832
- // want to require non-enumerability for this API, which
21833
- // would introduce a large cost.
21834
-
21835
- return intern(debugName + ' [id=' + GUID_KEY + Math.floor(Math.random() * new Date()) + ']');
21836
- }
21837
-
21838
22227
  /**
21839
22228
  A unique key used to assign guids and other private metadata to objects.
21840
22229
  If you inspect an object in your browser debugger you will often see these.
@@ -22297,6 +22686,9 @@ enifed('ember-metal/watch_key', ['exports', 'ember-metal/features', 'ember-metal
22297
22686
  exports.watchKey = watchKey;
22298
22687
  exports.unwatchKey = unwatchKey;
22299
22688
 
22689
+ var handleMandatorySetter = undefined,
22690
+ lookupDescriptor = undefined;
22691
+
22300
22692
  function watchKey(obj, keyName, meta) {
22301
22693
  // can't watch length on Array - it is special...
22302
22694
  if (keyName === 'length' && Array.isArray(obj)) {
@@ -22325,8 +22717,23 @@ enifed('ember-metal/watch_key', ['exports', 'ember-metal/features', 'ember-metal
22325
22717
  }
22326
22718
  }
22327
22719
 
22328
- var handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) {
22329
- var descriptor = Object.getOwnPropertyDescriptor && Object.getOwnPropertyDescriptor(obj, keyName);
22720
+ lookupDescriptor = function lookupDescriptor(obj, keyName) {
22721
+ var current = obj;
22722
+ while (current) {
22723
+ var descriptor = Object.getOwnPropertyDescriptor(current, keyName);
22724
+
22725
+ if (descriptor) {
22726
+ return descriptor;
22727
+ }
22728
+
22729
+ current = Object.getPrototypeOf(current);
22730
+ }
22731
+
22732
+ return null;
22733
+ };
22734
+
22735
+ handleMandatorySetter = function handleMandatorySetter(m, obj, keyName) {
22736
+ var descriptor = lookupDescriptor(obj, keyName);
22330
22737
  var configurable = descriptor ? descriptor.configurable : true;
22331
22738
  var isWritable = descriptor ? descriptor.writable : true;
22332
22739
  var hasValue = descriptor ? 'value' in descriptor : true;
@@ -22433,7 +22840,7 @@ enifed('ember-metal/watch_path', ['exports', 'ember-metal/meta', 'ember-metal/ch
22433
22840
  }
22434
22841
  }
22435
22842
  });
22436
- enifed('ember-metal/watching', ['exports', 'ember-metal/chains', 'ember-metal/watch_key', 'ember-metal/watch_path', 'ember-metal/path_cache'], function (exports, _emberMetalChains, _emberMetalWatch_key, _emberMetalWatch_path, _emberMetalPath_cache) {
22843
+ enifed('ember-metal/watching', ['exports', 'ember-metal/chains', 'ember-metal/watch_key', 'ember-metal/watch_path', 'ember-metal/path_cache', 'ember-metal/meta'], function (exports, _emberMetalChains, _emberMetalWatch_key, _emberMetalWatch_path, _emberMetalPath_cache, _emberMetalMeta) {
22437
22844
  /**
22438
22845
  @module ember-metal
22439
22846
  */
@@ -22473,7 +22880,7 @@ enifed('ember-metal/watching', ['exports', 'ember-metal/chains', 'ember-metal/wa
22473
22880
  exports.watch = watch;
22474
22881
 
22475
22882
  function isWatching(obj, key) {
22476
- var meta = obj['__ember_meta__'];
22883
+ var meta = _emberMetalMeta.peekMeta(obj);
22477
22884
  return (meta && meta.peekWatching(key)) > 0;
22478
22885
  }
22479
22886
 
@@ -22506,11 +22913,11 @@ enifed('ember-metal/watching', ['exports', 'ember-metal/chains', 'ember-metal/wa
22506
22913
  */
22507
22914
 
22508
22915
  function destroy(obj) {
22509
- var meta = obj['__ember_meta__'];
22916
+ var meta = _emberMetalMeta.peekMeta(obj);
22510
22917
  var node, nodes, key, nodeObject;
22511
22918
 
22512
22919
  if (meta) {
22513
- obj['__ember_meta__'] = null;
22920
+ _emberMetalMeta.deleteMeta(obj);
22514
22921
  // remove chainWatchers to remove circular references that would prevent GC
22515
22922
  node = meta.readableChains();
22516
22923
  if (node) {
@@ -22879,9 +23286,9 @@ enifed('ember-metal', ['exports', 'ember-metal/core', 'ember-metal/debug', 'embe
22879
23286
  _emberMetalCore.default.Error = _emberMetalError.default;
22880
23287
  _emberMetalCore.default.guidFor = _emberMetalUtils.guidFor;
22881
23288
  _emberMetalCore.default.META_DESC = _emberMetalMeta.META_DESC;
22882
- _emberMetalCore.default.EMPTY_META = _emberMetalMeta.EMPTY_META;
22883
23289
  _emberMetalCore.default.meta = _emberMetalMeta.meta;
22884
23290
  _emberMetalCore.default.inspect = _emberMetalUtils.inspect;
23291
+
22885
23292
  _emberMetalCore.default.tryCatchFinally = _emberMetalUtils.deprecatedTryCatchFinally;
22886
23293
  _emberMetalCore.default.makeArray = _emberMetalUtils.makeArray;
22887
23294
  _emberMetalCore.default.canInvoke = _emberMetalUtils.canInvoke;
@@ -22991,7 +23398,12 @@ enifed('ember-metal', ['exports', 'ember-metal/core', 'ember-metal/debug', 'embe
22991
23398
  _emberMetalCore.default.isBlank = _emberMetalIs_blank.default;
22992
23399
  _emberMetalCore.default.isPresent = _emberMetalIs_present.default;
22993
23400
 
22994
- _emberMetalCore.default.merge = _emberMetalMerge.default;
23401
+ if (_emberMetalFeatures.default('ember-metal-ember-assign')) {
23402
+ _emberMetalCore.default.assign = Object.assign || _emberMetalAssign.default;
23403
+ _emberMetalCore.default.merge = _emberMetalMerge.default;
23404
+ } else {
23405
+ _emberMetalCore.default.merge = _emberMetalMerge.default;
23406
+ }
22995
23407
 
22996
23408
  _emberMetalCore.default.FEATURES = _emberMetalFeatures.FEATURES;
22997
23409
  _emberMetalCore.default.FEATURES.isEnabled = _emberMetalFeatures.default;
@@ -23378,7 +23790,7 @@ enifed('ember-routing/location/api', ['exports', 'ember-metal/debug', 'ember-met
23378
23790
  }
23379
23791
  };
23380
23792
  });
23381
- enifed('ember-routing/location/auto_location', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-runtime/system/object', 'ember-metal/environment', 'ember-routing/location/util'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalUtils, _emberRuntimeSystemObject, _emberMetalEnvironment, _emberRoutingLocationUtil) {
23793
+ enifed('ember-routing/location/auto_location', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'container/owner', 'ember-runtime/system/object', 'ember-metal/environment', 'ember-routing/location/util'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalUtils, _containerOwner, _emberRuntimeSystemObject, _emberMetalEnvironment, _emberRoutingLocationUtil) {
23382
23794
  'use strict';
23383
23795
 
23384
23796
  exports.getHistoryPath = getHistoryPath;
@@ -23487,7 +23899,7 @@ enifed('ember-routing/location/auto_location', ['exports', 'ember-metal/debug',
23487
23899
  implementation = 'none';
23488
23900
  }
23489
23901
 
23490
- var concrete = this.container.lookup('location:' + implementation);
23902
+ var concrete = _containerOwner.getOwner(this).lookup('location:' + implementation);
23491
23903
  _emberMetalProperty_set.set(concrete, 'rootURL', rootURL);
23492
23904
 
23493
23905
  _emberMetalDebug.assert('Could not find location \'' + implementation + '\'.', !!concrete);
@@ -24532,10 +24944,10 @@ enifed('ember-routing/system/generate_controller', ['exports', 'ember-metal/debu
24532
24944
  @private
24533
24945
  */
24534
24946
 
24535
- function generateControllerFactory(container, controllerName, context) {
24947
+ function generateControllerFactory(owner, controllerName, context) {
24536
24948
  var Factory, fullName;
24537
24949
 
24538
- Factory = container.lookupFactory('controller:basic').extend({
24950
+ Factory = owner._lookupFactory('controller:basic').extend({
24539
24951
  isGenerated: true,
24540
24952
  toString: function () {
24541
24953
  return '(generated ' + controllerName + ' controller)';
@@ -24544,7 +24956,7 @@ enifed('ember-routing/system/generate_controller', ['exports', 'ember-metal/debu
24544
24956
 
24545
24957
  fullName = 'controller:' + controllerName;
24546
24958
 
24547
- container.registry.register(fullName, Factory);
24959
+ owner.register(fullName, Factory);
24548
24960
 
24549
24961
  return Factory;
24550
24962
  }
@@ -24563,11 +24975,11 @@ enifed('ember-routing/system/generate_controller', ['exports', 'ember-metal/debu
24563
24975
  @since 1.3.0
24564
24976
  */
24565
24977
 
24566
- function generateController(container, controllerName, context) {
24567
- generateControllerFactory(container, controllerName, context);
24978
+ function generateController(owner, controllerName, context) {
24979
+ generateControllerFactory(owner, controllerName, context);
24568
24980
 
24569
24981
  var fullName = 'controller:' + controllerName;
24570
- var instance = container.lookup(fullName);
24982
+ var instance = owner.lookup(fullName);
24571
24983
 
24572
24984
  if (_emberMetalProperty_get.get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {
24573
24985
  _emberMetalDebug.info('generated -> ' + fullName, { fullName: fullName });
@@ -24584,7 +24996,7 @@ enifed('ember-routing/system/query_params', ['exports', 'ember-runtime/system/ob
24584
24996
  values: null
24585
24997
  });
24586
24998
  });
24587
- enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/get_properties', 'ember-metal/is_none', 'ember-metal/computed', 'ember-metal/assign', 'ember-runtime/utils', 'ember-metal/run_loop', 'ember-runtime/copy', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/system/native_array', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/action_handler', 'ember-routing/system/generate_controller', 'ember-routing/utils'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalGet_properties, _emberMetalIs_none, _emberMetalComputed, _emberMetalAssign, _emberRuntimeUtils, _emberMetalRun_loop, _emberRuntimeCopy, _emberRuntimeSystemString, _emberRuntimeSystemObject, _emberRuntimeSystemNative_array, _emberRuntimeMixinsEvented, _emberRuntimeMixinsAction_handler, _emberRoutingSystemGenerate_controller, _emberRoutingUtils) {
24999
+ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/get_properties', 'ember-metal/is_none', 'ember-metal/computed', 'ember-metal/assign', 'ember-runtime/utils', 'ember-metal/run_loop', 'ember-runtime/copy', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/system/native_array', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/action_handler', 'ember-routing/system/generate_controller', 'ember-routing/utils', 'container/owner', 'ember-metal/is_empty'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalFeatures, _emberMetalError, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalGet_properties, _emberMetalIs_none, _emberMetalComputed, _emberMetalAssign, _emberRuntimeUtils, _emberMetalRun_loop, _emberRuntimeCopy, _emberRuntimeSystemString, _emberRuntimeSystemObject, _emberRuntimeSystemNative_array, _emberRuntimeMixinsEvented, _emberRuntimeMixinsAction_handler, _emberRoutingSystemGenerate_controller, _emberRoutingUtils, _containerOwner, _emberMetalIs_empty) {
24588
25000
  'use strict';
24589
25001
 
24590
25002
  var slice = Array.prototype.slice;
@@ -24671,7 +25083,7 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
24671
25083
  var controllerProto, combinedQueryParameterConfiguration;
24672
25084
 
24673
25085
  var controllerName = this.controllerName || this.routeName;
24674
- var definedControllerClass = this.container.lookupFactory('controller:' + controllerName);
25086
+ var definedControllerClass = _containerOwner.getOwner(this)._lookupFactory('controller:' + controllerName);
24675
25087
  var queryParameterConfiguraton = _emberMetalProperty_get.get(this, 'queryParams');
24676
25088
  var hasRouterDefinedQueryParams = !!Object.keys(queryParameterConfiguraton).length;
24677
25089
 
@@ -24685,10 +25097,16 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
24685
25097
  var controllerDefinedQueryParameterConfiguration = _emberMetalProperty_get.get(controllerProto, 'queryParams');
24686
25098
  var normalizedControllerQueryParameterConfiguration = _emberRoutingUtils.normalizeControllerQueryParams(controllerDefinedQueryParameterConfiguration);
24687
25099
  combinedQueryParameterConfiguration = mergeEachQueryParams(normalizedControllerQueryParameterConfiguration, queryParameterConfiguraton);
25100
+
25101
+ if (_emberMetalFeatures.default('ember-routing-route-configured-query-params')) {
25102
+ if (controllerDefinedQueryParameterConfiguration.length) {
25103
+ _emberMetalDebug.deprecate('Configuring query parameters on a controller is deprecated. Migrate the query parameters configuration from the \'' + controllerName + '\' controller to the \'' + this.routeName + '\' route: ' + combinedQueryParameterConfiguration, false, { id: 'ember-routing.controller-configured-query-params', until: '3.0.0' });
25104
+ }
25105
+ }
24688
25106
  } else if (hasRouterDefinedQueryParams) {
24689
25107
  // the developer has not defined a controller but *has* supplied route query params.
24690
25108
  // Generate a class for them so we can later insert default values
24691
- var generatedControllerClass = _emberRoutingSystemGenerate_controller.generateControllerFactory(this.container, controllerName);
25109
+ var generatedControllerClass = _emberRoutingSystemGenerate_controller.generateControllerFactory(_containerOwner.getOwner(this), controllerName);
24692
25110
  controllerProto = generatedControllerClass.proto();
24693
25111
  combinedQueryParameterConfiguration = queryParameterConfiguraton;
24694
25112
  }
@@ -24711,6 +25129,19 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
24711
25129
 
24712
25130
  var desc = combinedQueryParameterConfiguration[propName];
24713
25131
 
25132
+ if (_emberMetalFeatures.default('ember-routing-route-configured-query-params')) {
25133
+ // apply default values to controllers
25134
+ // detect that default value defined on router config
25135
+ if (desc.hasOwnProperty('defaultValue')) {
25136
+ // detect that property was not defined on controller
25137
+ if (controllerProto[propName] === undefined) {
25138
+ controllerProto[propName] = desc.defaultValue;
25139
+ } else {
25140
+ deprecateQueryParamDefaultValuesSetOnController(controllerName, this.routeName, propName);
25141
+ }
25142
+ }
25143
+ }
25144
+
24714
25145
  var scope = desc.scope || 'model';
24715
25146
  var parts;
24716
25147
 
@@ -24856,7 +25287,7 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
24856
25287
  @public
24857
25288
  */
24858
25289
  paramsFor: function (name) {
24859
- var route = this.container.lookup('route:' + name);
25290
+ var route = _containerOwner.getOwner(this).lookup('route:' + name);
24860
25291
 
24861
25292
  if (!route) {
24862
25293
  return {};
@@ -25665,7 +26096,9 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
25665
26096
 
25666
26097
  this.setupController(controller, context, transition);
25667
26098
 
25668
- this.renderTemplate(controller, context);
26099
+ if (!this._environment || this._environment.options.shouldRender) {
26100
+ this.renderTemplate(controller, context);
26101
+ }
25669
26102
  },
25670
26103
 
25671
26104
  /*
@@ -25940,13 +26373,13 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
25940
26373
  @private
25941
26374
  */
25942
26375
  store: _emberMetalComputed.computed(function () {
25943
- var container = this.container;
26376
+ var owner = _containerOwner.getOwner(this);
25944
26377
  var routeName = this.routeName;
25945
26378
  var namespace = _emberMetalProperty_get.get(this, 'router.namespace');
25946
26379
 
25947
26380
  return {
25948
26381
  find: function (name, value) {
25949
- var modelClass = container.lookupFactory('model:' + name);
26382
+ var modelClass = owner._lookupFactory('model:' + name);
25950
26383
 
25951
26384
  _emberMetalDebug.assert('You used the dynamic segment ' + name + '_id in your route ' + routeName + ', but ' + namespace + '.' + _emberRuntimeSystemString.classify(name) + ' did not exist and you did not override your route\'s `model` hook.', !!modelClass);
25952
26385
 
@@ -26088,15 +26521,15 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26088
26521
  @public
26089
26522
  */
26090
26523
  controllerFor: function (name, _skipAssert) {
26091
- var container = this.container;
26092
- var route = container.lookup('route:' + name);
26524
+ var owner = _containerOwner.getOwner(this);
26525
+ var route = owner.lookup('route:' + name);
26093
26526
  var controller;
26094
26527
 
26095
26528
  if (route && route.controllerName) {
26096
26529
  name = route.controllerName;
26097
26530
  }
26098
26531
 
26099
- controller = container.lookup('controller:' + name);
26532
+ controller = owner.lookup('controller:' + name);
26100
26533
 
26101
26534
  // NOTE: We're specifically checking that skipAssert is true, because according
26102
26535
  // to the old API the second parameter was model. We do not want people who
@@ -26123,11 +26556,11 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26123
26556
  @private
26124
26557
  */
26125
26558
  generateController: function (name, model) {
26126
- var container = this.container;
26559
+ var owner = _containerOwner.getOwner(this);
26127
26560
 
26128
26561
  model = model || this.modelFor(name);
26129
26562
 
26130
- return _emberRoutingSystemGenerate_controller.default(container, name, model);
26563
+ return _emberRoutingSystemGenerate_controller.default(owner, name, model);
26131
26564
  },
26132
26565
 
26133
26566
  /**
@@ -26158,7 +26591,7 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26158
26591
  @public
26159
26592
  */
26160
26593
  modelFor: function (name) {
26161
- var route = this.container.lookup('route:' + name);
26594
+ var route = _containerOwner.getOwner(this).lookup('route:' + name);
26162
26595
  var transition = this.router ? this.router.router.activeTransition : null;
26163
26596
 
26164
26597
  // If we are mid-transition, we want to try and look up
@@ -26307,7 +26740,7 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26307
26740
  _emberMetalDebug.assert('The name in the given arguments is undefined', arguments.length > 0 ? !_emberMetalIs_none.default(arguments[0]) : true);
26308
26741
 
26309
26742
  var namePassed = typeof _name === 'string' && !!_name;
26310
- var isDefaultRender = arguments.length === 0 || _emberMetalCore.default.isEmpty(arguments[0]);
26743
+ var isDefaultRender = arguments.length === 0 || _emberMetalIs_empty.default(arguments[0]);
26311
26744
  var name;
26312
26745
 
26313
26746
  if (typeof _name === 'object' && !options) {
@@ -26469,15 +26902,15 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26469
26902
 
26470
26903
  if (!controller) {
26471
26904
  if (namePassed) {
26472
- controller = route.container.lookup('controller:' + name) || route.controllerName || route.routeName;
26905
+ controller = _containerOwner.getOwner(route).lookup('controller:' + name) || route.controllerName || route.routeName;
26473
26906
  } else {
26474
- controller = route.controllerName || route.container.lookup('controller:' + name);
26907
+ controller = route.controllerName || _containerOwner.getOwner(route).lookup('controller:' + name);
26475
26908
  }
26476
26909
  }
26477
26910
 
26478
26911
  if (typeof controller === 'string') {
26479
26912
  var controllerName = controller;
26480
- controller = route.container.lookup('controller:' + controllerName);
26913
+ controller = _containerOwner.getOwner(route).lookup('controller:' + controllerName);
26481
26914
  if (!controller) {
26482
26915
  throw new _emberMetalError.default('You passed `controller: \'' + controllerName + '\'` into the `render` method, but no such controller could be found.');
26483
26916
  }
@@ -26491,9 +26924,10 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26491
26924
  controller.set('model', options.model);
26492
26925
  }
26493
26926
 
26927
+ var owner = _containerOwner.getOwner(route);
26494
26928
  viewName = options && options.view || namePassed && name || route.viewName || name;
26495
- ViewClass = route.container.lookupFactory('view:' + viewName);
26496
- template = route.container.lookup('template:' + templateName);
26929
+ ViewClass = owner._lookupFactory('view:' + viewName);
26930
+ template = owner.lookup('template:' + templateName);
26497
26931
 
26498
26932
  var parent;
26499
26933
  if (into && (parent = parentRoute(route)) && into === parentRoute(route).routeName) {
@@ -26510,6 +26944,17 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26510
26944
  };
26511
26945
 
26512
26946
  var Component = undefined;
26947
+ if (_emberMetalFeatures.default('ember-routing-routable-components')) {
26948
+ var componentName = options && options.component || namePassed && name || route.componentName || name;
26949
+ var componentLookup = owner.lookup('component-lookup:main');
26950
+ Component = componentLookup.lookupFactory(componentName);
26951
+ var isGlimmerComponent = Component && Component.proto().isGlimmerComponent;
26952
+ if (!template && !ViewClass && Component && isGlimmerComponent) {
26953
+ renderOptions.Component = Component;
26954
+ renderOptions.ViewClass = undefined;
26955
+ renderOptions.attrs = { model: _emberMetalProperty_get.get(controller, 'model') };
26956
+ }
26957
+ }
26513
26958
 
26514
26959
  if (!ViewClass && !template && !Component) {
26515
26960
  _emberMetalDebug.assert('Could not find "' + name + '" template, view, or component.', isDefaultRender);
@@ -26577,12 +27022,16 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26577
27022
  var keysAlreadyMergedOrSkippable;
26578
27023
  var qps = {};
26579
27024
 
26580
- keysAlreadyMergedOrSkippable = {
26581
- defaultValue: true,
26582
- type: true,
26583
- scope: true,
26584
- as: true
26585
- };
27025
+ if (_emberMetalFeatures.default('ember-routing-route-configured-query-params')) {
27026
+ keysAlreadyMergedOrSkippable = {};
27027
+ } else {
27028
+ keysAlreadyMergedOrSkippable = {
27029
+ defaultValue: true,
27030
+ type: true,
27031
+ scope: true,
27032
+ as: true
27033
+ };
27034
+ }
26586
27035
 
26587
27036
  // first loop over all controller qps, merging them with any matching route qps
26588
27037
  // into a new empty object to avoid mutating.
@@ -26629,12 +27078,7 @@ enifed('ember-routing/system/route', ['exports', 'ember-metal/core', 'ember-meta
26629
27078
  exports.default = Route;
26630
27079
  });
26631
27080
  // FEATURES, A, deprecate, assert, Logger
26632
-
26633
- // apply default values to controllers
26634
- // detect that default value defined on router config
26635
-
26636
- // detect that property was not defined on controller
26637
- enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-metal/debug', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/properties', 'ember-metal/empty_object', 'ember-metal/computed', 'ember-metal/assign', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-routing/system/dsl', 'ember-routing/location/api', 'ember-routing/utils', 'ember-routing/system/router_state', 'router', 'router/transition'], function (exports, _emberMetalLogger, _emberMetalDebug, _emberMetalError, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalProperties, _emberMetalEmpty_object, _emberMetalComputed, _emberMetalAssign, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberRuntimeMixinsEvented, _emberRoutingSystemDsl, _emberRoutingLocationApi, _emberRoutingUtils, _emberRoutingSystemRouter_state, _router4, _routerTransition) {
27081
+ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-metal/debug', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/properties', 'ember-metal/empty_object', 'ember-metal/computed', 'ember-metal/assign', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-routing/system/dsl', 'ember-routing/location/api', 'ember-routing/utils', 'ember-routing/system/router_state', 'container/owner', 'router', 'router/transition'], function (exports, _emberMetalLogger, _emberMetalDebug, _emberMetalError, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalProperties, _emberMetalEmpty_object, _emberMetalComputed, _emberMetalAssign, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberRuntimeMixinsEvented, _emberRoutingSystemDsl, _emberRoutingLocationApi, _emberRoutingUtils, _emberRoutingSystemRouter_state, _containerOwner, _router4, _routerTransition) {
26638
27082
  'use strict';
26639
27083
 
26640
27084
  function K() {
@@ -26845,9 +27289,10 @@ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-m
26845
27289
  defaultParentState = ownState;
26846
27290
  }
26847
27291
  if (!this._toplevelView) {
26848
- var OutletView = this.container.lookupFactory('view:-outlet');
27292
+ var owner = _containerOwner.getOwner(this);
27293
+ var OutletView = owner._lookupFactory('view:-outlet');
26849
27294
  this._toplevelView = OutletView.create();
26850
- var instance = this.container.lookup('-application-instance:main');
27295
+ var instance = owner.lookup('-application-instance:main');
26851
27296
  instance.didCreateRootView(this._toplevelView);
26852
27297
  }
26853
27298
  this._toplevelView.setOutletState(liveRoutes);
@@ -27047,9 +27492,10 @@ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-m
27047
27492
  _setupLocation: function () {
27048
27493
  var location = _emberMetalProperty_get.get(this, 'location');
27049
27494
  var rootURL = _emberMetalProperty_get.get(this, 'rootURL');
27495
+ var owner = _containerOwner.getOwner(this);
27050
27496
 
27051
- if ('string' === typeof location && this.container) {
27052
- var resolvedLocation = this.container.lookup('location:' + location);
27497
+ if ('string' === typeof location && owner) {
27498
+ var resolvedLocation = owner.lookup('location:' + location);
27053
27499
 
27054
27500
  if ('undefined' !== typeof resolvedLocation) {
27055
27501
  location = _emberMetalProperty_set.set(this, 'location', resolvedLocation);
@@ -27087,12 +27533,12 @@ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-m
27087
27533
  var _this2 = this;
27088
27534
 
27089
27535
  var seen = new _emberMetalEmpty_object.default();
27090
- var container = this.container;
27091
- var DefaultRoute = container.lookupFactory('route:basic');
27536
+ var owner = _containerOwner.getOwner(this);
27537
+ var DefaultRoute = owner._lookupFactory('route:basic');
27092
27538
 
27093
27539
  return function (name) {
27094
27540
  var routeName = 'route:' + name;
27095
- var handler = container.lookup(routeName);
27541
+ var handler = owner.lookup(routeName);
27096
27542
 
27097
27543
  if (seen[name]) {
27098
27544
  return handler;
@@ -27101,8 +27547,8 @@ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-m
27101
27547
  seen[name] = true;
27102
27548
 
27103
27549
  if (!handler) {
27104
- container.registry.register(routeName, DefaultRoute.extend());
27105
- handler = container.lookup(routeName);
27550
+ owner.register(routeName, DefaultRoute.extend());
27551
+ handler = owner.lookup(routeName);
27106
27552
 
27107
27553
  if (_emberMetalProperty_get.get(_this2, 'namespace.LOG_ACTIVE_GENERATION')) {
27108
27554
  _emberMetalDebug.info('generated -> ' + routeName, { fullName: routeName });
@@ -27451,8 +27897,8 @@ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-m
27451
27897
  }
27452
27898
 
27453
27899
  function routeHasBeenDefined(router, name) {
27454
- var container = router.container;
27455
- return router.hasRoute(name) && (container.registry.has('template:' + name) || container.registry.has('route:' + name));
27900
+ var owner = _containerOwner.getOwner(router);
27901
+ return router.hasRoute(name) && (owner.hasRegistration('template:' + name) || owner.hasRegistration('route:' + name));
27456
27902
  }
27457
27903
 
27458
27904
  function triggerEvent(handlerInfos, ignoreFailure, args) {
@@ -27515,7 +27961,7 @@ enifed('ember-routing/system/router', ['exports', 'ember-metal/logger', 'ember-m
27515
27961
  _emberMetalProperty_set.set(router, 'currentPath', path);
27516
27962
  _emberMetalProperty_set.set(router, 'currentRouteName', currentRouteName);
27517
27963
 
27518
- var appController = router.container.lookup('controller:application');
27964
+ var appController = _containerOwner.getOwner(router).lookup('controller:application');
27519
27965
 
27520
27966
  if (!appController) {
27521
27967
  // appController might not exist when top-level loading/error
@@ -28259,13 +28705,13 @@ enifed('ember-routing-htmlbars/keywords/action', ['exports', 'htmlbars-runtime/h
28259
28705
  return _emberRoutingHtmlbarsKeywordsClosureAction.default(morph, env, scope, params, hash, template, inverse, visitor);
28260
28706
  };
28261
28707
  });
28262
- enifed('ember-routing-htmlbars/keywords/closure-action', ['exports', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-metal/utils', 'ember-metal/property_get', 'ember-htmlbars/hooks/subexpr', 'ember-metal/error', 'ember-metal/run_loop'], function (exports, _emberMetalStreamsStream, _emberMetalStreamsUtils, _emberMetalUtils, _emberMetalProperty_get, _emberHtmlbarsHooksSubexpr, _emberMetalError, _emberMetalRun_loop) {
28708
+ enifed('ember-routing-htmlbars/keywords/closure-action', ['exports', 'ember-metal/streams/stream', 'ember-metal/streams/utils', 'ember-metal/symbol', 'ember-metal/property_get', 'ember-htmlbars/hooks/subexpr', 'ember-metal/error', 'ember-metal/run_loop'], function (exports, _emberMetalStreamsStream, _emberMetalStreamsUtils, _emberMetalSymbol, _emberMetalProperty_get, _emberHtmlbarsHooksSubexpr, _emberMetalError, _emberMetalRun_loop) {
28263
28709
  'use strict';
28264
28710
 
28265
28711
  exports.default = closureAction;
28266
- var INVOKE = _emberMetalUtils.symbol('INVOKE');
28712
+ var INVOKE = _emberMetalSymbol.default('INVOKE');
28267
28713
  exports.INVOKE = INVOKE;
28268
- var ACTION = _emberMetalUtils.symbol('ACTION');
28714
+ var ACTION = _emberMetalSymbol.default('ACTION');
28269
28715
 
28270
28716
  exports.ACTION = ACTION;
28271
28717
 
@@ -28623,14 +29069,14 @@ enifed('ember-routing-htmlbars/keywords/render', ['exports', 'ember-metal/debug'
28623
29069
  var name = params[0];
28624
29070
  var context = params[1];
28625
29071
 
28626
- var container = env.container;
29072
+ var owner = env.owner;
28627
29073
 
28628
29074
  // The render keyword presumes it can work without a router. This is really
28629
29075
  // only to satisfy the test:
28630
29076
  //
28631
29077
  // {{view}} should not override class bindings defined on a child view"
28632
29078
  //
28633
- var router = container.lookup('router:main');
29079
+ var router = owner.lookup('router:main');
28634
29080
 
28635
29081
  _emberMetalDebug.assert('The second argument of {{render}} must be a path, e.g. {{render "post" post}}.', params.length < 2 || _emberMetalStreamsUtils.isStream(params[1]));
28636
29082
 
@@ -28642,15 +29088,15 @@ enifed('ember-routing-htmlbars/keywords/render', ['exports', 'ember-metal/debug'
28642
29088
  }
28643
29089
 
28644
29090
  var templateName = 'template:' + name;
28645
- _emberMetalDebug.assert('You used `{{render \'' + name + '\'}}`, but \'' + name + '\' can not be ' + 'found as either a template or a view.', container.registry.has('view:' + name) || container.registry.has(templateName) || !!template);
29091
+ _emberMetalDebug.assert('You used `{{render \'' + name + '\'}}`, but \'' + name + '\' can not be ' + 'found as either a template or a view.', owner.hasRegistration('view:' + name) || owner.hasRegistration(templateName) || !!template);
28646
29092
 
28647
- var view = container.lookup('view:' + name);
29093
+ var view = owner.lookup('view:' + name);
28648
29094
  if (!view) {
28649
- view = container.lookup('view:default');
29095
+ view = owner.lookup('view:default');
28650
29096
  }
28651
29097
  var viewHasTemplateSpecified = view && !!_emberMetalProperty_get.get(view, 'template');
28652
29098
  if (!template && !viewHasTemplateSpecified) {
28653
- template = container.lookup(templateName);
29099
+ template = owner.lookup(templateName);
28654
29100
  }
28655
29101
 
28656
29102
  if (view) {
@@ -28666,7 +29112,7 @@ enifed('ember-routing-htmlbars/keywords/render', ['exports', 'ember-metal/debug'
28666
29112
  controllerFullName = 'controller:' + controllerName;
28667
29113
  delete hash.controller;
28668
29114
 
28669
- _emberMetalDebug.assert('The controller name you supplied \'' + controllerName + '\' ' + 'did not resolve to a controller.', container.registry.has(controllerFullName));
29115
+ _emberMetalDebug.assert('The controller name you supplied \'' + controllerName + '\' ' + 'did not resolve to a controller.', owner.hasRegistration(controllerFullName));
28670
29116
  } else {
28671
29117
  controllerName = name;
28672
29118
  controllerFullName = 'controller:' + controllerName;
@@ -28677,7 +29123,7 @@ enifed('ember-routing-htmlbars/keywords/render', ['exports', 'ember-metal/debug'
28677
29123
 
28678
29124
  // choose name
28679
29125
  if (params.length > 1) {
28680
- var factory = container.lookupFactory(controllerFullName) || _emberRoutingSystemGenerate_controller.generateControllerFactory(container, controllerName);
29126
+ var factory = owner._lookupFactory(controllerFullName) || _emberRoutingSystemGenerate_controller.generateControllerFactory(owner, controllerName);
28681
29127
 
28682
29128
  controller = factory.create({
28683
29129
  model: _emberMetalStreamsUtils.read(context),
@@ -28687,7 +29133,7 @@ enifed('ember-routing-htmlbars/keywords/render', ['exports', 'ember-metal/debug'
28687
29133
 
28688
29134
  node.addDestruction(controller);
28689
29135
  } else {
28690
- controller = container.lookup(controllerFullName) || _emberRoutingSystemGenerate_controller.default(container, controllerName);
29136
+ controller = owner.lookup(controllerFullName) || _emberRoutingSystemGenerate_controller.default(owner, controllerName);
28691
29137
 
28692
29138
  controller.setProperties({
28693
29139
  target: parentController,
@@ -29125,7 +29571,7 @@ enifed('ember-routing-views/components/link-to', ['exports', 'ember-metal/logger
29125
29571
 
29126
29572
  'use strict';
29127
29573
 
29128
- _emberHtmlbarsTemplatesLinkTo.default.meta.revision = 'Ember@2.2.1';
29574
+ _emberHtmlbarsTemplatesLinkTo.default.meta.revision = 'Ember@2.3.0-beta.1';
29129
29575
 
29130
29576
  /**
29131
29577
  `Ember.LinkComponent` renders an element whose `click` event triggers a
@@ -29615,7 +30061,7 @@ enifed('ember-routing-views/views/outlet', ['exports', 'ember-views/views/view',
29615
30061
 
29616
30062
  'use strict';
29617
30063
 
29618
- _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.2.1';
30064
+ _emberHtmlbarsTemplatesTopLevelView.default.meta.revision = 'Ember@2.3.0-beta.1';
29619
30065
 
29620
30066
  var CoreOutletView = _emberViewsViewsView.default.extend({
29621
30067
  defaultTemplate: _emberHtmlbarsTemplatesTopLevelView.default,
@@ -29805,7 +30251,7 @@ enifed('ember-runtime/compare', ['exports', 'ember-runtime/utils', 'ember-runtim
29805
30251
  }
29806
30252
  }
29807
30253
  });
29808
- enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/computed', 'ember-metal/observer', 'ember-runtime/compare', 'ember-runtime/utils', 'ember-runtime/system/native_array'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalError, _emberMetalComputed, _emberMetalObserver, _emberRuntimeCompare, _emberRuntimeUtils, _emberRuntimeSystemNative_array) {
30254
+ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/computed', 'ember-metal/observer', 'ember-runtime/compare', 'ember-runtime/utils', 'ember-runtime/system/native_array', 'ember-metal/is_none', 'ember-metal/get_properties'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalError, _emberMetalComputed, _emberMetalObserver, _emberRuntimeCompare, _emberRuntimeUtils, _emberRuntimeSystemNative_array, _emberMetalIs_none, _emberMetalGet_properties) {
29809
30255
  /**
29810
30256
  @module ember
29811
30257
  @submodule ember-runtime
@@ -29823,6 +30269,7 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-metal
29823
30269
  exports.uniq = uniq;
29824
30270
  exports.intersect = intersect;
29825
30271
  exports.setDiff = setDiff;
30272
+ exports.collect = collect;
29826
30273
  exports.sort = sort;
29827
30274
 
29828
30275
  function reduceMacro(dependentKey, callback, initialValue) {
@@ -30327,6 +30774,54 @@ enifed('ember-runtime/computed/reduce_computed_macros', ['exports', 'ember-metal
30327
30774
  }).readOnly();
30328
30775
  }
30329
30776
 
30777
+ /**
30778
+ A computed property that returns the array of values
30779
+ for the provided dependent properties.
30780
+
30781
+ Example
30782
+
30783
+ ```javascript
30784
+ var Hamster = Ember.Object.extend({
30785
+ clothes: Ember.computed.collect('hat', 'shirt')
30786
+ });
30787
+
30788
+ var hamster = Hamster.create();
30789
+
30790
+ hamster.get('clothes'); // [null, null]
30791
+ hamster.set('hat', 'Camp Hat');
30792
+ hamster.set('shirt', 'Camp Shirt');
30793
+ hamster.get('clothes'); // ['Camp Hat', 'Camp Shirt']
30794
+ ```
30795
+
30796
+ @method collect
30797
+ @for Ember.computed
30798
+ @param {String} dependentKey*
30799
+ @return {Ember.ComputedProperty} computed property which maps
30800
+ values of all passed in properties to an array.
30801
+ @public
30802
+ */
30803
+
30804
+ function collect() {
30805
+ for (var _len3 = arguments.length, dependentKeys = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
30806
+ dependentKeys[_key3] = arguments[_key3];
30807
+ }
30808
+
30809
+ return multiArrayMacro(dependentKeys, function () {
30810
+ var properties = _emberMetalGet_properties.default(this, dependentKeys);
30811
+ var res = _emberRuntimeSystemNative_array.A();
30812
+ for (var key in properties) {
30813
+ if (properties.hasOwnProperty(key)) {
30814
+ if (_emberMetalIs_none.default(properties[key])) {
30815
+ res.push(null);
30816
+ } else {
30817
+ res.push(properties[key]);
30818
+ }
30819
+ }
30820
+ }
30821
+ return res;
30822
+ });
30823
+ }
30824
+
30330
30825
  /**
30331
30826
  A computed property which returns a new array with all the
30332
30827
  properties from the first dependent array sorted based on a property
@@ -31931,13 +32426,15 @@ enifed('ember-runtime/mixins/comparable', ['exports', 'ember-metal/mixin'], func
31931
32426
  compare: null
31932
32427
  });
31933
32428
  });
31934
- enifed('ember-runtime/mixins/container_proxy', ['exports', 'ember-metal/run_loop', 'ember-metal/mixin'], function (exports, _emberMetalRun_loop, _emberMetalMixin) {
32429
+ enifed('ember-runtime/mixins/container_proxy', ['exports', 'ember-metal/run_loop', 'ember-metal/debug', 'ember-metal/mixin'], function (exports, _emberMetalRun_loop, _emberMetalDebug, _emberMetalMixin) {
31935
32430
  /**
31936
32431
  @module ember
31937
32432
  @submodule ember-runtime
31938
32433
  */
31939
32434
  'use strict';
31940
32435
 
32436
+ exports.buildFakeContainerWithDeprecations = buildFakeContainerWithDeprecations;
32437
+
31941
32438
  /**
31942
32439
  ContainerProxyMixin is used to provide public access to specific
31943
32440
  container functionality.
@@ -32014,6 +32511,31 @@ enifed('ember-runtime/mixins/container_proxy', ['exports', 'ember-metal/run_loop
32014
32511
  return (_container__ = this.__container__)[name].apply(_container__, arguments);
32015
32512
  };
32016
32513
  }
32514
+
32515
+ function buildFakeContainerWithDeprecations(container) {
32516
+ var fakeContainer = {};
32517
+ var propertyMappings = {
32518
+ lookup: 'lookup',
32519
+ lookupFactory: '_lookupFactory'
32520
+ };
32521
+
32522
+ for (var containerProperty in propertyMappings) {
32523
+ fakeContainer[containerProperty] = buildFakeContainerFunction(container, containerProperty, propertyMappings[containerProperty]);
32524
+ }
32525
+
32526
+ return fakeContainer;
32527
+ }
32528
+
32529
+ function buildFakeContainerFunction(container, containerProperty, ownerProperty) {
32530
+ return function () {
32531
+ _emberMetalDebug.deprecate('Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `' + ownerProperty + '` instead.', false, {
32532
+ id: 'ember-application.injected-container',
32533
+ until: '3.0.0',
32534
+ url: 'http://emberjs.com/deprecations/v2.x#toc_injected-container-access'
32535
+ });
32536
+ return container[containerProperty].apply(container, arguments);
32537
+ };
32538
+ }
32017
32539
  });
32018
32540
  enifed('ember-runtime/mixins/controller', ['exports', 'ember-metal/mixin', 'ember-metal/alias', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/controller_content_model_alias_deprecation'], function (exports, _emberMetalMixin, _emberMetalAlias, _emberRuntimeMixinsAction_handler, _emberRuntimeMixinsController_content_model_alias_deprecation) {
32019
32541
  'use strict';
@@ -32046,8 +32568,6 @@ enifed('ember-runtime/mixins/controller', ['exports', 'ember-metal/mixin', 'embe
32046
32568
  */
32047
32569
  target: null,
32048
32570
 
32049
- container: null,
32050
-
32051
32571
  parentController: null,
32052
32572
 
32053
32573
  store: null,
@@ -32169,7 +32689,7 @@ enifed('ember-runtime/mixins/copyable', ['exports', 'ember-metal/debug', 'ember-
32169
32689
  }
32170
32690
  });
32171
32691
  });
32172
- enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/property_events', 'ember-metal/events', 'ember-runtime/compare'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalMixin, _emberMetalComputed, _emberMetalProperty_events, _emberMetalEvents, _emberRuntimeCompare) {
32692
+ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/property_events', 'ember-metal/events', 'ember-runtime/compare', 'require'], function (exports, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalMixin, _emberMetalComputed, _emberMetalProperty_events, _emberMetalEvents, _emberRuntimeCompare, _require) {
32173
32693
  /**
32174
32694
  @module ember
32175
32695
  @submodule ember-runtime
@@ -32181,6 +32701,12 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32181
32701
 
32182
32702
  'use strict';
32183
32703
 
32704
+ var _emberA = undefined;
32705
+
32706
+ function emberA() {
32707
+ return (_emberA || (_emberA = _require.default('ember-runtime/system/native_array').A))();
32708
+ }
32709
+
32184
32710
  var contexts = [];
32185
32711
 
32186
32712
  function popCtx() {
@@ -32458,7 +32984,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32458
32984
  @public
32459
32985
  */
32460
32986
  map: function (callback, target) {
32461
- var ret = _emberMetalCore.default.A();
32987
+ var ret = emberA();
32462
32988
 
32463
32989
  this.forEach(function (x, idx, i) {
32464
32990
  ret[idx] = callback.call(target, x, idx, i);
@@ -32505,7 +33031,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32505
33031
  @public
32506
33032
  */
32507
33033
  filter: function (callback, target) {
32508
- var ret = _emberMetalCore.default.A();
33034
+ var ret = emberA();
32509
33035
 
32510
33036
  this.forEach(function (x, idx, i) {
32511
33037
  if (callback.call(target, x, idx, i)) {
@@ -32816,7 +33342,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32816
33342
  args[_key - 1] = arguments[_key];
32817
33343
  }
32818
33344
 
32819
- var ret = _emberMetalCore.default.A();
33345
+ var ret = emberA();
32820
33346
 
32821
33347
  this.forEach(function (x, idx) {
32822
33348
  var method = x && x[methodName];
@@ -32837,7 +33363,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32837
33363
  @public
32838
33364
  */
32839
33365
  toArray: function () {
32840
- var ret = _emberMetalCore.default.A();
33366
+ var ret = emberA();
32841
33367
 
32842
33368
  this.forEach(function (o, idx) {
32843
33369
  ret[idx] = o;
@@ -32880,7 +33406,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32880
33406
  return this; // nothing to do
32881
33407
  }
32882
33408
 
32883
- var ret = _emberMetalCore.default.A();
33409
+ var ret = emberA();
32884
33410
 
32885
33411
  this.forEach(function (k) {
32886
33412
  if (k !== value) {
@@ -32904,7 +33430,7 @@ enifed('ember-runtime/mixins/enumerable', ['exports', 'ember-metal/core', 'ember
32904
33430
  @public
32905
33431
  */
32906
33432
  uniq: function () {
32907
- var ret = _emberMetalCore.default.A();
33433
+ var ret = emberA();
32908
33434
 
32909
33435
  this.forEach(function (k) {
32910
33436
  if (ret.indexOf(k) < 0) {
@@ -34887,6 +35413,29 @@ enifed('ember-runtime/mixins/target_action_support', ['exports', 'ember-metal/co
34887
35413
  exports.default = TargetActionSupport;
34888
35414
  });
34889
35415
  // Ember.lookup
35416
+ enifed("ember-runtime/string_registry", ["exports"], function (exports) {
35417
+ // STATE within a module is frowned apon, this exists
35418
+ // to support Ember.STRINGS but shield ember internals from this legacy global
35419
+ // API.
35420
+ "use strict";
35421
+
35422
+ exports.setStrings = setStrings;
35423
+ exports.getStrings = getStrings;
35424
+ exports.get = get;
35425
+ var STRINGS = {};
35426
+
35427
+ function setStrings(strings) {
35428
+ STRINGS = strings;
35429
+ }
35430
+
35431
+ function getStrings() {
35432
+ return STRINGS;
35433
+ }
35434
+
35435
+ function get(name) {
35436
+ return STRINGS[name];
35437
+ }
35438
+ });
34890
35439
  enifed('ember-runtime/system/application', ['exports', 'ember-runtime/system/namespace'], function (exports, _emberRuntimeSystemNamespace) {
34891
35440
  'use strict';
34892
35441
 
@@ -35253,7 +35802,7 @@ enifed('ember-runtime/system/array_proxy', ['exports', 'ember-metal/debug', 'emb
35253
35802
 
35254
35803
  exports.default = ArrayProxy;
35255
35804
  });
35256
- enifed('ember-runtime/system/container', ['exports', 'ember-metal/property_set', 'container/registry', 'container/container'], function (exports, _emberMetalProperty_set, _containerRegistry, _containerContainer) {
35805
+ enifed('ember-runtime/system/container', ['exports', 'ember-metal/property_set', 'container/registry', 'container/container', 'container/owner'], function (exports, _emberMetalProperty_set, _containerRegistry, _containerContainer, _containerOwner) {
35257
35806
  'use strict';
35258
35807
 
35259
35808
  _containerRegistry.default.set = _emberMetalProperty_set.set;
@@ -35261,8 +35810,10 @@ enifed('ember-runtime/system/container', ['exports', 'ember-metal/property_set',
35261
35810
 
35262
35811
  exports.Registry = _containerRegistry.default;
35263
35812
  exports.Container = _containerContainer.default;
35813
+ exports.getOwner = _containerOwner.getOwner;
35814
+ exports.setOwner = _containerOwner.setOwner;
35264
35815
  });
35265
- enifed('ember-runtime/system/core_object', ['exports', 'ember-metal', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/assign', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/chains', 'ember-metal/events', 'ember-metal/mixin', 'ember-metal/error', 'ember-runtime/mixins/action_handler', 'ember-metal/properties', 'ember-metal/binding', 'ember-metal/computed', 'ember-metal/injected_property', 'ember-metal/run_loop', 'ember-metal/watching', 'ember-metal/core', 'ember-runtime/inject'], function (exports, _emberMetal, _emberMetalDebug, _emberMetalFeatures, _emberMetalAssign, _emberMetalProperty_get, _emberMetalUtils, _emberMetalMeta, _emberMetalChains, _emberMetalEvents, _emberMetalMixin, _emberMetalError, _emberRuntimeMixinsAction_handler, _emberMetalProperties, _emberMetalBinding, _emberMetalComputed, _emberMetalInjected_property, _emberMetalRun_loop, _emberMetalWatching, _emberMetalCore, _emberRuntimeInject) {
35816
+ enifed('ember-runtime/system/core_object', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/assign', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/meta', 'ember-metal/chains', 'ember-metal/events', 'ember-metal/mixin', 'ember-metal/error', 'ember-runtime/mixins/action_handler', 'ember-metal/properties', 'ember-metal/binding', 'ember-metal/computed', 'ember-metal/injected_property', 'ember-metal/run_loop', 'ember-metal/watching', 'ember-metal/core', 'ember-runtime/inject', 'ember-metal/symbol'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalAssign, _emberMetalProperty_get, _emberMetalUtils, _emberMetalMeta, _emberMetalChains, _emberMetalEvents, _emberMetalMixin, _emberMetalError, _emberRuntimeMixinsAction_handler, _emberMetalProperties, _emberMetalBinding, _emberMetalComputed, _emberMetalInjected_property, _emberMetalRun_loop, _emberMetalWatching, _emberMetalCore, _emberRuntimeInject, _emberMetalSymbol) {
35266
35817
  'no use strict';
35267
35818
  // Remove "use strict"; from transpiled module until
35268
35819
  // https://bugs.webkit.org/show_bug.cgi?id=138038 is fixed
@@ -35277,7 +35828,7 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-metal', 'ember-met
35277
35828
 
35278
35829
  var _Mixin$create;
35279
35830
 
35280
- var POST_INIT = _emberMetalUtils.symbol('POST_INIT');
35831
+ var POST_INIT = _emberMetalSymbol.default('POST_INIT');
35281
35832
  exports.POST_INIT = POST_INIT;
35282
35833
  var schedule = _emberMetalRun_loop.default.schedule;
35283
35834
  var applyMixin = _emberMetalMixin.Mixin._apply;
@@ -35883,8 +36434,8 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-metal', 'ember-met
35883
36434
  if (hasCachedComputedProperties === false) {
35884
36435
  return;
35885
36436
  }
35886
- if (value instanceof _emberMetal.default.ComputedProperty) {
35887
- var cache = _emberMetal.default.meta(this.constructor).readableCache();
36437
+ if (value instanceof _emberMetalComputed.ComputedProperty) {
36438
+ var cache = _emberMetalMeta.meta(this.constructor).readableCache();
35888
36439
 
35889
36440
  if (cache && cache._computedProperties !== undefined) {
35890
36441
  cache._computedProperties = undefined;
@@ -36385,10 +36936,9 @@ enifed('ember-runtime/system/namespace', ['exports', 'ember-metal/core', 'ember-
36385
36936
  paths[idx] = key;
36386
36937
 
36387
36938
  // If we have found an unprocessed class
36388
- if (obj && obj.toString === classToString) {
36939
+ if (obj && obj.toString === classToString && !obj[NAME_KEY]) {
36389
36940
  // Replace the class' `toString` with the dot-separated path
36390
36941
  // and set its `NAME_KEY`
36391
- obj.toString = makeToString(paths.join('.'));
36392
36942
  obj[NAME_KEY] = paths.join('.');
36393
36943
 
36394
36944
  // Support nested namespaces
@@ -36647,44 +37197,21 @@ enifed('ember-runtime/system/native_array', ['exports', 'ember-metal/core', 'emb
36647
37197
  @return {Ember.NativeArray}
36648
37198
  @public
36649
37199
  */
36650
- var A = function (arr) {
36651
- if (arr === undefined) {
36652
- arr = [];
36653
- }
36654
- return _emberRuntimeMixinsArray.default.detect(arr) ? arr : NativeArray.apply(arr);
36655
- };
37200
+ var A;
36656
37201
 
36657
- /**
36658
- Activates the mixin on the Array.prototype if not already applied. Calling
36659
- this method more than once is safe. This will be called when ember is loaded
36660
- unless you have `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Array`
36661
- set to `false`.
36662
-
36663
- Example
36664
-
36665
- ```js
36666
- if (Ember.EXTEND_PROTOTYPES === true || Ember.EXTEND_PROTOTYPES.Array) {
36667
- Ember.NativeArray.activate();
36668
- }
36669
- ```
36670
-
36671
- @method activate
36672
- @for Ember.NativeArray
36673
- @static
36674
- @return {void}
36675
- @private
36676
- */
36677
- NativeArray.activate = function () {
37202
+ if (_emberMetalCore.default.EXTEND_PROTOTYPES === true || _emberMetalCore.default.EXTEND_PROTOTYPES.Array) {
36678
37203
  NativeArray.apply(Array.prototype);
36679
-
36680
37204
  exports. // ES6TODO: Setting A onto the object returned by ember-metal/core to avoid circles
36681
37205
  A = A = function (arr) {
36682
37206
  return arr || [];
36683
37207
  };
36684
- };
36685
-
36686
- if (_emberMetalCore.default.EXTEND_PROTOTYPES === true || _emberMetalCore.default.EXTEND_PROTOTYPES.Array) {
36687
- NativeArray.activate();
37208
+ } else {
37209
+ exports.A = A = function (arr) {
37210
+ if (arr === undefined) {
37211
+ arr = [];
37212
+ }
37213
+ return _emberRuntimeMixinsArray.default.detect(arr) ? arr : NativeArray.apply(arr);
37214
+ };
36688
37215
  }
36689
37216
 
36690
37217
  _emberMetalCore.default.A = A;exports.A = A;
@@ -36841,7 +37368,7 @@ enifed('ember-runtime/system/service', ['exports', 'ember-runtime/system/object'
36841
37368
 
36842
37369
  exports.default = Service;
36843
37370
  });
36844
- enifed('ember-runtime/system/string', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/utils', 'ember-runtime/utils', 'ember-metal/cache'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalUtils, _emberRuntimeUtils, _emberMetalCache) {
37371
+ enifed('ember-runtime/system/string', ['exports', 'ember-metal/debug', 'ember-metal/utils', 'ember-runtime/utils', 'ember-runtime/string_registry', 'ember-metal/cache'], function (exports, _emberMetalDebug, _emberMetalUtils, _emberRuntimeUtils, _emberRuntimeString_registry, _emberMetalCache) {
36845
37372
  /**
36846
37373
  @module ember
36847
37374
  @submodule ember-runtime
@@ -36936,7 +37463,7 @@ enifed('ember-runtime/system/string', ['exports', 'ember-metal/core', 'ember-met
36936
37463
  formats = Array.prototype.slice.call(arguments, 1);
36937
37464
  }
36938
37465
 
36939
- str = _emberMetalCore.default.STRINGS[str] || str;
37466
+ str = _emberRuntimeString_registry.get(str) || str;
36940
37467
  return _fmt(str, formats);
36941
37468
  }
36942
37469
 
@@ -36968,18 +37495,6 @@ enifed('ember-runtime/system/string', ['exports', 'ember-metal/core', 'ember-met
36968
37495
  return CAPITALIZE_CACHE.get(str);
36969
37496
  }
36970
37497
 
36971
- /**
36972
- Defines the hash of localized strings for the current language. Used by
36973
- the `Ember.String.loc()` helper. To localize, add string values to this
36974
- hash.
36975
-
36976
- @property STRINGS
36977
- @for Ember
36978
- @type Object
36979
- @private
36980
- */
36981
- _emberMetalCore.default.STRINGS = {};
36982
-
36983
37498
  /**
36984
37499
  Defines string helper methods including string formatting and localization.
36985
37500
  Unless `Ember.EXTEND_PROTOTYPES.String` is `false` these methods will also be
@@ -37161,7 +37676,6 @@ enifed('ember-runtime/system/string', ['exports', 'ember-metal/core', 'ember-met
37161
37676
  exports.underscore = underscore;
37162
37677
  exports.capitalize = capitalize;
37163
37678
  });
37164
- // Ember.STRINGS
37165
37679
  enifed('ember-runtime/utils', ['exports', 'ember-runtime/mixins/array', 'ember-runtime/system/object'], function (exports, _emberRuntimeMixinsArray, _emberRuntimeSystemObject) {
37166
37680
  'use strict';
37167
37681
 
@@ -37310,7 +37824,7 @@ enifed('ember-runtime/utils', ['exports', 'ember-runtime/mixins/array', 'ember-r
37310
37824
  return ret;
37311
37825
  }
37312
37826
  });
37313
- enifed('ember-runtime', ['exports', 'ember-metal', 'ember-runtime/is-equal', 'ember-runtime/compare', 'ember-runtime/copy', 'ember-runtime/inject', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/container', 'ember-runtime/system/array_proxy', 'ember-runtime/system/object_proxy', 'ember-runtime/system/core_object', 'ember-runtime/system/native_array', 'ember-runtime/system/string', 'ember-runtime/system/lazy_load', 'ember-runtime/mixins/array', 'ember-runtime/mixins/comparable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/freezable', 'ember-runtime/mixins/-proxy', 'ember-runtime/mixins/observable', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/target_action_support', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/promise_proxy', 'ember-runtime/computed/reduce_computed_macros', 'ember-runtime/controllers/controller', 'ember-runtime/mixins/controller', 'ember-runtime/system/service', 'ember-runtime/ext/rsvp', 'ember-runtime/ext/string', 'ember-runtime/ext/function', 'ember-runtime/utils'], function (exports, _emberMetal, _emberRuntimeIsEqual, _emberRuntimeCompare, _emberRuntimeCopy, _emberRuntimeInject, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject, _emberRuntimeSystemContainer, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemObject_proxy, _emberRuntimeSystemCore_object, _emberRuntimeSystemNative_array, _emberRuntimeSystemString, _emberRuntimeSystemLazy_load, _emberRuntimeMixinsArray, _emberRuntimeMixinsComparable, _emberRuntimeMixinsCopyable, _emberRuntimeMixinsEnumerable, _emberRuntimeMixinsFreezable, _emberRuntimeMixinsProxy, _emberRuntimeMixinsObservable, _emberRuntimeMixinsAction_handler, _emberRuntimeMixinsMutable_enumerable, _emberRuntimeMixinsMutable_array, _emberRuntimeMixinsTarget_action_support, _emberRuntimeMixinsEvented, _emberRuntimeMixinsPromise_proxy, _emberRuntimeComputedReduce_computed_macros, _emberRuntimeControllersController, _emberRuntimeMixinsController, _emberRuntimeSystemService, _emberRuntimeExtRsvp, _emberRuntimeExtString, _emberRuntimeExtFunction, _emberRuntimeUtils) {
37827
+ enifed('ember-runtime', ['exports', 'ember-metal', 'ember-runtime/is-equal', 'ember-runtime/compare', 'ember-runtime/copy', 'ember-runtime/inject', 'ember-runtime/system/namespace', 'ember-runtime/system/object', 'ember-runtime/system/container', 'ember-runtime/system/array_proxy', 'ember-runtime/system/object_proxy', 'ember-runtime/system/core_object', 'ember-runtime/system/native_array', 'ember-runtime/system/string', 'ember-runtime/system/lazy_load', 'ember-runtime/mixins/array', 'ember-runtime/mixins/comparable', 'ember-runtime/mixins/copyable', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/freezable', 'ember-runtime/mixins/-proxy', 'ember-runtime/mixins/observable', 'ember-runtime/mixins/action_handler', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/mixins/mutable_array', 'ember-runtime/mixins/target_action_support', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/promise_proxy', 'ember-runtime/computed/reduce_computed_macros', 'ember-runtime/controllers/controller', 'ember-runtime/mixins/controller', 'ember-runtime/system/service', 'ember-runtime/ext/rsvp', 'ember-runtime/ext/string', 'ember-runtime/ext/function', 'ember-runtime/utils', 'ember-metal/features', 'ember-runtime/mixins/registry_proxy', 'ember-runtime/mixins/container_proxy', 'ember-runtime/string_registry'], function (exports, _emberMetal, _emberRuntimeIsEqual, _emberRuntimeCompare, _emberRuntimeCopy, _emberRuntimeInject, _emberRuntimeSystemNamespace, _emberRuntimeSystemObject, _emberRuntimeSystemContainer, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemObject_proxy, _emberRuntimeSystemCore_object, _emberRuntimeSystemNative_array, _emberRuntimeSystemString, _emberRuntimeSystemLazy_load, _emberRuntimeMixinsArray, _emberRuntimeMixinsComparable, _emberRuntimeMixinsCopyable, _emberRuntimeMixinsEnumerable, _emberRuntimeMixinsFreezable, _emberRuntimeMixinsProxy, _emberRuntimeMixinsObservable, _emberRuntimeMixinsAction_handler, _emberRuntimeMixinsMutable_enumerable, _emberRuntimeMixinsMutable_array, _emberRuntimeMixinsTarget_action_support, _emberRuntimeMixinsEvented, _emberRuntimeMixinsPromise_proxy, _emberRuntimeComputedReduce_computed_macros, _emberRuntimeControllersController, _emberRuntimeMixinsController, _emberRuntimeSystemService, _emberRuntimeExtRsvp, _emberRuntimeExtString, _emberRuntimeExtFunction, _emberRuntimeUtils, _emberMetalFeatures, _emberRuntimeMixinsRegistry_proxy, _emberRuntimeMixinsContainer_proxy, _emberRuntimeString_registry) {
37314
37828
  /**
37315
37829
  @module ember
37316
37830
  @submodule ember-runtime
@@ -37369,6 +37883,13 @@ enifed('ember-runtime', ['exports', 'ember-metal', 'ember-runtime/is-equal', 'em
37369
37883
  _emberMetal.default.Object = _emberRuntimeSystemObject.default;
37370
37884
  _emberMetal.default.Container = _emberRuntimeSystemContainer.Container;
37371
37885
  _emberMetal.default.Registry = _emberRuntimeSystemContainer.Registry;
37886
+
37887
+ _emberMetal.default.getOwner = _emberRuntimeSystemContainer.getOwner;
37888
+ _emberMetal.default.setOwner = _emberRuntimeSystemContainer.setOwner;
37889
+
37890
+ _emberMetal.default._RegistryProxyMixin = _emberRuntimeMixinsRegistry_proxy.default;
37891
+ _emberMetal.default._ContainerProxyMixin = _emberRuntimeMixinsContainer_proxy.default;
37892
+
37372
37893
  _emberMetal.default.Namespace = _emberRuntimeSystemNamespace.default;
37373
37894
  _emberMetal.default.Enumerable = _emberRuntimeMixinsEnumerable.default;
37374
37895
  _emberMetal.default.ArrayProxy = _emberRuntimeSystemArray_proxy.default;
@@ -37391,6 +37912,22 @@ enifed('ember-runtime', ['exports', 'ember-metal', 'ember-runtime/is-equal', 'em
37391
37912
  _emberMetal.default.RSVP = _emberRuntimeExtRsvp.default;
37392
37913
  // END EXPORTS
37393
37914
 
37915
+ /**
37916
+ Defines the hash of localized strings for the current language. Used by
37917
+ the `Ember.String.loc()` helper. To localize, add string values to this
37918
+ hash.
37919
+
37920
+ @property STRINGS
37921
+ @for Ember
37922
+ @type Object
37923
+ @private
37924
+ */
37925
+ Object.defineProperty(_emberMetal.default, 'STRINGS', {
37926
+ configurable: false,
37927
+ get: _emberRuntimeString_registry.getStrings,
37928
+ set: _emberRuntimeString_registry.setStrings
37929
+ });
37930
+
37394
37931
  exports.default = _emberMetal.default;
37395
37932
  });
37396
37933
  // just for side effect of extending Ember.RSVP
@@ -38273,6 +38810,9 @@ enifed('ember-template-compiler/plugins/transform-top-level-components', ['expor
38273
38810
 
38274
38811
  if (lastComponentNode.type === 'ComponentNode') {
38275
38812
  componentCallback(lastComponentNode);
38813
+ } else if (_emberMetalFeatures.default('ember-htmlbars-component-generation')) {
38814
+ var component = elementCallback(lastComponentNode);
38815
+ body.splice(lastIndex, 1, component);
38276
38816
  }
38277
38817
  }
38278
38818
 
@@ -38425,6 +38965,9 @@ enifed('ember-template-compiler/system/compile_options', ['exports', 'ember-meta
38425
38965
 
38426
38966
  exports.default = function (_options) {
38427
38967
  var disableComponentGeneration = true;
38968
+ if (_emberMetalFeatures.default('ember-htmlbars-component-generation')) {
38969
+ disableComponentGeneration = false;
38970
+ }
38428
38971
 
38429
38972
  var options = undefined;
38430
38973
  // When calling `Ember.Handlebars.compile()` a second argument of `true`
@@ -38450,7 +38993,7 @@ enifed('ember-template-compiler/system/compile_options', ['exports', 'ember-meta
38450
38993
  options.buildMeta = function buildMeta(program) {
38451
38994
  return {
38452
38995
  fragmentReason: fragmentReason(program),
38453
- revision: 'Ember@2.2.1',
38996
+ revision: 'Ember@2.3.0-beta.1',
38454
38997
  loc: program.loc,
38455
38998
  moduleName: options.moduleName
38456
38999
  };
@@ -38686,7 +39229,7 @@ enifed('ember-testing/adapters/qunit', ['exports', 'ember-testing/adapters/adapt
38686
39229
  }
38687
39230
  });
38688
39231
  });
38689
- enifed('ember-testing/helpers', ['exports', 'ember-metal/debug', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-testing/test', 'ember-runtime/ext/rsvp'], function (exports, _emberMetalDebug, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalError, _emberMetalRun_loop, _emberViewsSystemJquery, _emberTestingTest, _emberRuntimeExtRsvp) {
39232
+ enifed('ember-testing/helpers', ['exports', 'ember-metal/property_get', 'ember-metal/error', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-testing/test', 'ember-runtime/ext/rsvp'], function (exports, _emberMetalProperty_get, _emberMetalError, _emberMetalRun_loop, _emberViewsSystemJquery, _emberTestingTest, _emberRuntimeExtRsvp) {
38690
39233
  'use strict';
38691
39234
 
38692
39235
  /**
@@ -38773,32 +39316,6 @@ enifed('ember-testing/helpers', ['exports', 'ember-metal/debug', 'ember-metal/fe
38773
39316
  return app.testHelpers.wait();
38774
39317
  }
38775
39318
 
38776
- function check(app, selector, context) {
38777
- var $el = app.testHelpers.findWithAssert(selector, context);
38778
- var type = $el.prop('type');
38779
-
38780
- _emberMetalDebug.assert('To check \'' + selector + '\', the input must be a checkbox', type === 'checkbox');
38781
-
38782
- if (!$el.prop('checked')) {
38783
- app.testHelpers.click(selector, context);
38784
- }
38785
-
38786
- return app.testHelpers.wait();
38787
- }
38788
-
38789
- function uncheck(app, selector, context) {
38790
- var $el = app.testHelpers.findWithAssert(selector, context);
38791
- var type = $el.prop('type');
38792
-
38793
- _emberMetalDebug.assert('To uncheck \'' + selector + '\', the input must be a checkbox', type === 'checkbox');
38794
-
38795
- if ($el.prop('checked')) {
38796
- app.testHelpers.click(selector, context);
38797
- }
38798
-
38799
- return app.testHelpers.wait();
38800
- }
38801
-
38802
39319
  function triggerEvent(app, selector, contextOrType, typeOrOptions, possibleOptions) {
38803
39320
  var arity = arguments.length;
38804
39321
  var context, type, options;
@@ -39177,36 +39694,6 @@ enifed('ember-testing/helpers', ['exports', 'ember-metal/debug', 'ember-metal/fe
39177
39694
  */
39178
39695
  asyncHelper('triggerEvent', triggerEvent);
39179
39696
  });
39180
-
39181
- /**
39182
- Checks a checkbox. Ensures the presence of the `checked` attribute
39183
- Example:
39184
- ```javascript
39185
- check('#remember-me').then(function() {
39186
- // assert something
39187
- });
39188
- ```
39189
- @method check
39190
- @param {String} selector jQuery selector finding an `input[type="checkbox"]`
39191
- element on the DOM to check
39192
- @return {RSVP.Promise}
39193
- @private
39194
- */
39195
-
39196
- /**
39197
- Unchecks a checkbox. Ensures the absence of the `checked` attribute
39198
- Example:
39199
- ```javascript
39200
- uncheck('#remember-me').then(function() {
39201
- // assert something
39202
- });
39203
- ```
39204
- @method check
39205
- @param {String} selector jQuery selector finding an `input[type="checkbox"]`
39206
- element on the DOM to uncheck
39207
- @return {RSVP.Promise}
39208
- @private
39209
- */
39210
39697
  enifed('ember-testing/initializers', ['exports', 'ember-runtime/system/lazy_load'], function (exports, _emberRuntimeSystemLazy_load) {
39211
39698
  'use strict';
39212
39699
 
@@ -39843,7 +40330,7 @@ enifed('ember-testing', ['exports', 'ember-metal/core', 'ember-testing/initializ
39843
40330
  });
39844
40331
  // to setup initializer
39845
40332
  // to handle various edge cases
39846
- enifed('ember-views/compat/attrs-proxy', ['exports', 'ember-metal/mixin', 'ember-metal/utils', 'ember-metal/property_events'], function (exports, _emberMetalMixin, _emberMetalUtils, _emberMetalProperty_events) {
40333
+ enifed('ember-views/compat/attrs-proxy', ['exports', 'ember-metal/mixin', 'ember-metal/symbol', 'ember-metal/property_events'], function (exports, _emberMetalMixin, _emberMetalSymbol, _emberMetalProperty_events) {
39847
40334
  'use strict';
39848
40335
 
39849
40336
  exports.deprecation = deprecation;
@@ -39852,7 +40339,7 @@ enifed('ember-views/compat/attrs-proxy', ['exports', 'ember-metal/mixin', 'ember
39852
40339
  return 'You tried to look up an attribute directly on the component. This is deprecated. Use attrs.' + key + ' instead.';
39853
40340
  }
39854
40341
 
39855
- var MUTABLE_CELL = _emberMetalUtils.symbol('MUTABLE_CELL');
40342
+ var MUTABLE_CELL = _emberMetalSymbol.default('MUTABLE_CELL');
39856
40343
 
39857
40344
  exports.MUTABLE_CELL = MUTABLE_CELL;
39858
40345
  function isCell(val) {
@@ -39950,7 +40437,7 @@ enifed('ember-views/compat/metamorph_view', ['exports', 'ember-metal/debug', 'em
39950
40437
  __metamorphType: 'Ember._MetamorphView'
39951
40438
  });
39952
40439
  });
39953
- enifed('ember-views/component_lookup', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-runtime/system/object', 'ember-htmlbars/system/lookup-helper'], function (exports, _emberMetalCore, _emberMetalDebug, _emberRuntimeSystemObject, _emberHtmlbarsSystemLookupHelper) {
40440
+ enifed('ember-views/component_lookup', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-runtime/system/object', 'ember-htmlbars/system/lookup-helper', 'container/owner'], function (exports, _emberMetalCore, _emberMetalDebug, _emberRuntimeSystemObject, _emberHtmlbarsSystemLookupHelper, _containerOwner) {
39954
40441
  'use strict';
39955
40442
 
39956
40443
  exports.default = _emberRuntimeSystemObject.default.extend({
@@ -39961,50 +40448,50 @@ enifed('ember-views/component_lookup', ['exports', 'ember-metal/core', 'ember-me
39961
40448
  }
39962
40449
  },
39963
40450
 
39964
- lookupFactory: function (name, container) {
39965
- container = container || this.container;
40451
+ lookupFactory: function (name, owner) {
40452
+ owner = owner || _containerOwner.getOwner(this);
39966
40453
 
39967
40454
  var fullName = 'component:' + name;
39968
40455
  var templateFullName = 'template:components/' + name;
39969
- var templateRegistered = container && container.registry.has(templateFullName);
40456
+ var templateRegistered = owner && owner.hasRegistration(templateFullName);
39970
40457
 
39971
40458
  if (templateRegistered) {
39972
- container.registry.injection(fullName, 'layout', templateFullName);
40459
+ owner.inject(fullName, 'layout', templateFullName);
39973
40460
  }
39974
40461
 
39975
- var Component = container.lookupFactory(fullName);
40462
+ var Component = owner._lookupFactory(fullName);
39976
40463
 
39977
40464
  // Only treat as a component if either the component
39978
40465
  // or a template has been registered.
39979
40466
  if (templateRegistered || Component) {
39980
40467
  if (!Component) {
39981
- container.registry.register(fullName, _emberMetalCore.default.Component);
39982
- Component = container.lookupFactory(fullName);
40468
+ owner.register(fullName, _emberMetalCore.default.Component);
40469
+ Component = owner._lookupFactory(fullName);
39983
40470
  }
39984
40471
  return Component;
39985
40472
  }
39986
40473
  },
39987
40474
 
39988
- componentFor: function (name, container) {
40475
+ componentFor: function (name, owner) {
39989
40476
  if (this.invalidName(name)) {
39990
40477
  return;
39991
40478
  }
39992
40479
 
39993
40480
  var fullName = 'component:' + name;
39994
- return container.lookupFactory(fullName);
40481
+ return owner._lookupFactory(fullName);
39995
40482
  },
39996
40483
 
39997
- layoutFor: function (name, container) {
40484
+ layoutFor: function (name, owner) {
39998
40485
  if (this.invalidName(name)) {
39999
40486
  return;
40000
40487
  }
40001
40488
 
40002
40489
  var templateFullName = 'template:components/' + name;
40003
- return container.lookup(templateFullName);
40490
+ return owner.lookup(templateFullName);
40004
40491
  }
40005
40492
  });
40006
40493
  });
40007
- enifed('ember-views/components/component', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-runtime/mixins/target_action_support', 'ember-views/views/view', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/computed', 'ember-views/compat/attrs-proxy'], function (exports, _emberMetalCore, _emberMetalDebug, _emberRuntimeMixinsTarget_action_support, _emberViewsViewsView, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalIs_none, _emberMetalComputed, _emberViewsCompatAttrsProxy) {
40494
+ enifed('ember-views/components/component', ['exports', 'ember-metal/debug', 'ember-runtime/mixins/target_action_support', 'ember-views/views/view', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/utils', 'ember-metal/computed', 'ember-views/compat/attrs-proxy', 'container/owner'], function (exports, _emberMetalDebug, _emberRuntimeMixinsTarget_action_support, _emberViewsViewsView, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalIs_none, _emberMetalUtils, _emberMetalComputed, _emberViewsCompatAttrsProxy, _containerOwner) {
40008
40495
  'use strict';
40009
40496
 
40010
40497
  function validateAction(component, actionName) {
@@ -40129,7 +40616,7 @@ enifed('ember-views/components/component', ['exports', 'ember-metal/core', 'embe
40129
40616
  _emberMetalProperty_set.set(this, 'controller', this);
40130
40617
  _emberMetalProperty_set.set(this, 'context', this);
40131
40618
 
40132
- if (!this.layout && this.layoutName && this.container) {
40619
+ if (!this.layout && this.layoutName && _containerOwner.getOwner(this)) {
40133
40620
  var layoutName = _emberMetalProperty_get.get(this, 'layoutName');
40134
40621
 
40135
40622
  this.layout = this.templateForName(layoutName);
@@ -40139,14 +40626,18 @@ enifed('ember-views/components/component', ['exports', 'ember-metal/core', 'embe
40139
40626
  // `layout` is no longer a CP, so this just ensures that the `defaultLayout`
40140
40627
  // logic is supported with a deprecation
40141
40628
  if (this.defaultLayout && !this.layout) {
40142
- _emberMetalDebug.deprecate('Specifying `defaultLayout` to ' + this + ' is deprecated. Please use `layout` instead.', false, { id: 'ember-views.component.defaultLayout', until: '3.0.0' });
40629
+ _emberMetalDebug.deprecate('Specifying `defaultLayout` to ' + this + ' is deprecated. Please use `layout` instead.', false, {
40630
+ id: 'ember-views.component.defaultLayout',
40631
+ until: '3.0.0',
40632
+ url: 'http://emberjs.com/deprecations/v2.x/#toc_ember-component-defaultlayout'
40633
+ });
40143
40634
 
40144
40635
  this.layout = this.defaultLayout;
40145
40636
  }
40146
40637
 
40147
40638
  // If in a tagless component, assert that no event handlers are defined
40148
40639
  _emberMetalDebug.assert('You can not define a function that handles DOM events in the `' + this + '` tagless component since it doesn\'t have any DOM element.', this.tagName !== '' || !(function () {
40149
- var eventDispatcher = _this.container.lookup('event_dispatcher:main');
40640
+ var eventDispatcher = _containerOwner.getOwner(_this).lookup('event_dispatcher:main');
40150
40641
  var events = eventDispatcher && eventDispatcher._finalEvents || {};
40151
40642
 
40152
40643
  for (var key in events) {
@@ -40271,7 +40762,7 @@ enifed('ember-views/components/component', ['exports', 'ember-metal/core', 'embe
40271
40762
  }
40272
40763
 
40273
40764
  if (typeof actionName === 'function') {
40274
- actionName.apply(null, contexts);
40765
+ actionName.apply(undefined, contexts);
40275
40766
  } else {
40276
40767
  this.triggerAction({
40277
40768
  action: actionName,
@@ -40286,10 +40777,10 @@ enifed('ember-views/components/component', ['exports', 'ember-metal/core', 'embe
40286
40777
  }
40287
40778
 
40288
40779
  var target;
40289
- var hasAction = this.actions && this.actions[actionName];
40780
+ var action = this.actions && this.actions[actionName];
40290
40781
 
40291
- if (hasAction) {
40292
- var shouldBubble = this.actions[actionName].apply(this, args) === true;
40782
+ if (action) {
40783
+ var shouldBubble = action.apply(this, args) === true;
40293
40784
  if (!shouldBubble) {
40294
40785
  return;
40295
40786
  }
@@ -40301,8 +40792,8 @@ enifed('ember-views/components/component', ['exports', 'ember-metal/core', 'embe
40301
40792
  _emberMetalDebug.assert('The `target` for ' + this + ' (' + target + ') does not have a `send` method', typeof target.send === 'function');
40302
40793
  (_target = target).send.apply(_target, arguments);
40303
40794
  } else {
40304
- if (!hasAction) {
40305
- throw new Error(_emberMetalCore.default.inspect(this) + ' had no action handler for: ' + actionName);
40795
+ if (!action) {
40796
+ throw new Error(_emberMetalUtils.inspect(this) + ' had no action handler for: ' + actionName);
40306
40797
  }
40307
40798
  }
40308
40799
  }
@@ -40636,12 +41127,12 @@ enifed('ember-views/mixins/instrumentation_support', ['exports', 'ember-metal/mi
40636
41127
 
40637
41128
  exports.default = InstrumentationSupport;
40638
41129
  });
40639
- enifed('ember-views/mixins/legacy_child_views_support', ['exports', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, _emberMetalMixin, _emberMetalProperty_get, _emberMetalProperty_set) {
41130
+ enifed('ember-views/mixins/legacy_child_views_support', ['exports', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/property_set', 'container/owner'], function (exports, _emberMetalMixin, _emberMetalProperty_get, _emberMetalProperty_set, _containerOwner) {
40640
41131
  'use strict';
40641
41132
 
40642
41133
  exports.default = _emberMetalMixin.Mixin.create({
40643
41134
  linkChild: function (instance) {
40644
- instance.container = this.container;
41135
+ _containerOwner.setOwner(instance, _containerOwner.getOwner(this));
40645
41136
  if (_emberMetalProperty_get.get(instance, 'parentView') !== this) {
40646
41137
  // linkChild should be idempotent
40647
41138
  _emberMetalProperty_set.set(instance, 'parentView', this);
@@ -40809,6 +41300,11 @@ enifed('ember-views/mixins/text_support', ['exports', 'ember-metal/property_get'
40809
41300
 
40810
41301
  'use strict';
40811
41302
 
41303
+ var KEY_EVENTS = {
41304
+ 13: 'insertNewline',
41305
+ 27: 'cancel'
41306
+ };
41307
+
40812
41308
  /**
40813
41309
  `TextSupport` is a shared mixin used by both `Ember.TextField` and
40814
41310
  `Ember.TextArea`. `TextSupport` adds a number of methods that allow you to
@@ -40962,7 +41458,7 @@ enifed('ember-views/mixins/text_support', ['exports', 'ember-metal/property_get'
40962
41458
  bubbles: false,
40963
41459
 
40964
41460
  interpretKeyEvents: function (event) {
40965
- var map = TextSupport.KEY_EVENTS;
41461
+ var map = KEY_EVENTS;
40966
41462
  var method = map[event.keyCode];
40967
41463
 
40968
41464
  this._elementValueDidChange();
@@ -41092,11 +41588,6 @@ enifed('ember-views/mixins/text_support', ['exports', 'ember-metal/property_get'
41092
41588
  }
41093
41589
  });
41094
41590
 
41095
- TextSupport.KEY_EVENTS = {
41096
- 13: 'insertNewline',
41097
- 27: 'cancel'
41098
- };
41099
-
41100
41591
  // In principle, this shouldn't be necessary, but the legacy
41101
41592
  // sendAction semantics for TextField are different from
41102
41593
  // the component semantics so this method normalizes them.
@@ -41123,7 +41614,7 @@ enifed('ember-views/mixins/text_support', ['exports', 'ember-metal/property_get'
41123
41614
 
41124
41615
  exports.default = TextSupport;
41125
41616
  });
41126
- enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/debug', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/set_properties', 'ember-runtime/system/native_array'], function (exports, _emberMetalDebug, _emberMetalMixin, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalSet_properties, _emberRuntimeSystemNative_array) {
41617
+ enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/debug', 'ember-metal/mixin', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/set_properties', 'ember-runtime/system/native_array', 'container/owner'], function (exports, _emberMetalDebug, _emberMetalMixin, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalSet_properties, _emberRuntimeSystemNative_array, _containerOwner) {
41127
41618
  /**
41128
41619
  @module ember
41129
41620
  @submodule ember-views
@@ -41207,7 +41698,9 @@ enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/d
41207
41698
  throw new TypeError('createChildViews first argument must exist');
41208
41699
  }
41209
41700
 
41210
- if (maybeViewClass.isView && maybeViewClass.parentView === this && maybeViewClass.container === this.container) {
41701
+ var owner = _containerOwner.getOwner(this);
41702
+
41703
+ if (maybeViewClass.isView && maybeViewClass.parentView === this && _containerOwner.getOwner(maybeViewClass) === owner) {
41211
41704
  return maybeViewClass;
41212
41705
  }
41213
41706
 
@@ -41219,7 +41712,7 @@ enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/d
41219
41712
  attrs._viewRegistry = this._viewRegistry;
41220
41713
 
41221
41714
  if (maybeViewClass.isViewFactory) {
41222
- attrs.container = this.container;
41715
+ _containerOwner.setOwner(attrs, owner);
41223
41716
 
41224
41717
  view = maybeViewClass.create(attrs);
41225
41718
 
@@ -41228,7 +41721,7 @@ enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/d
41228
41721
  }
41229
41722
  } else if ('string' === typeof maybeViewClass) {
41230
41723
  var fullName = 'view:' + maybeViewClass;
41231
- var ViewKlass = this.container.lookupFactory(fullName);
41724
+ var ViewKlass = owner._lookupFactory(fullName);
41232
41725
 
41233
41726
  _emberMetalDebug.assert('Could not find view: \'' + fullName + '\'', !!ViewKlass);
41234
41727
 
@@ -41237,7 +41730,7 @@ enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/d
41237
41730
  view = maybeViewClass;
41238
41731
  _emberMetalDebug.assert('You must pass instance or subclass of View', view.isView);
41239
41732
 
41240
- attrs.container = this.container;
41733
+ _containerOwner.setOwner(attrs, owner);
41241
41734
  _emberMetalSet_properties.default(view, attrs);
41242
41735
  }
41243
41736
 
@@ -41247,7 +41740,7 @@ enifed('ember-views/mixins/view_child_views_support', ['exports', 'ember-metal/d
41247
41740
  },
41248
41741
 
41249
41742
  linkChild: function (instance) {
41250
- instance.container = this.container;
41743
+ _containerOwner.setOwner(instance, _containerOwner.getOwner(this));
41251
41744
  instance.parentView = this;
41252
41745
  instance.ownerView = this.ownerView;
41253
41746
  },
@@ -41379,12 +41872,12 @@ enifed('ember-views/mixins/view_state_support', ['exports', 'ember-metal/debug',
41379
41872
 
41380
41873
  exports.default = ViewStateSupport;
41381
41874
  });
41382
- enifed('ember-views/mixins/view_support', ['exports', 'ember-metal/debug', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-metal/utils', 'ember-metal/computed', 'ember-metal/mixin', 'ember-runtime/system/core_object', 'ember-metal/features', 'ember-views/system/jquery'], function (exports, _emberMetalDebug, _emberMetalError, _emberMetalProperty_get, _emberMetalRun_loop, _emberMetalObserver, _emberMetalUtils, _emberMetalComputed, _emberMetalMixin, _emberRuntimeSystemCore_object, _emberMetalFeatures, _emberViewsSystemJquery) {
41875
+ enifed('ember-views/mixins/view_support', ['exports', 'ember-metal/debug', 'ember-metal/error', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-metal/utils', 'ember-metal/computed', 'ember-metal/mixin', 'ember-runtime/system/core_object', 'ember-metal/features', 'ember-metal/symbol', 'container/owner', 'ember-views/system/jquery'], function (exports, _emberMetalDebug, _emberMetalError, _emberMetalProperty_get, _emberMetalRun_loop, _emberMetalObserver, _emberMetalUtils, _emberMetalComputed, _emberMetalMixin, _emberRuntimeSystemCore_object, _emberMetalFeatures, _emberMetalSymbol, _containerOwner, _emberViewsSystemJquery) {
41383
41876
  'use strict';
41384
41877
 
41385
41878
  var _Mixin$create;
41386
41879
 
41387
- var INIT_WAS_CALLED = _emberMetalUtils.symbol('INIT_WAS_CALLED');
41880
+ var INIT_WAS_CALLED = _emberMetalSymbol.default('INIT_WAS_CALLED');
41388
41881
 
41389
41882
  function K() {
41390
41883
  return this;
@@ -41487,11 +41980,13 @@ enifed('ember-views/mixins/view_support', ['exports', 'ember-metal/debug', 'embe
41487
41980
  }
41488
41981
  _emberMetalDebug.assert('templateNames are not allowed to contain periods: ' + name, name.indexOf('.') === -1);
41489
41982
 
41490
- if (!this.container) {
41983
+ var owner = _containerOwner.getOwner(this);
41984
+
41985
+ if (!owner) {
41491
41986
  throw new _emberMetalError.default('Container was not found when looking up a views template. ' + 'This is most likely due to manually instantiating an Ember.View. ' + 'See: http://git.io/EKPpnA');
41492
41987
  }
41493
41988
 
41494
- return this.container.lookup('template:' + name);
41989
+ return owner.lookup('template:' + name);
41495
41990
  },
41496
41991
 
41497
41992
  /**
@@ -41619,12 +42114,23 @@ enifed('ember-views/mixins/view_support', ['exports', 'ember-metal/debug', 'embe
41619
42114
  @private
41620
42115
  */
41621
42116
  appendTo: function (selector) {
41622
- var target = _emberViewsSystemJquery.default(selector);
42117
+ var $ = this._environment ? this._environment.options.jQuery : _emberViewsSystemJquery.default;
42118
+
42119
+ if ($) {
42120
+ var target = $(selector);
42121
+
42122
+ _emberMetalDebug.assert('You tried to append to (' + selector + ') but that isn\'t in the DOM', target.length > 0);
42123
+ _emberMetalDebug.assert('You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.', !target.is('.ember-view') && !target.parents().is('.ember-view'));
42124
+
42125
+ this.renderer.appendTo(this, target[0]);
42126
+ } else {
42127
+ var target = selector;
41623
42128
 
41624
- _emberMetalDebug.assert('You tried to append to (' + selector + ') but that isn\'t in the DOM', target.length > 0);
41625
- _emberMetalDebug.assert('You cannot append to an existing Ember.View. Consider using Ember.ContainerView instead.', !target.is('.ember-view') && !target.parents().is('.ember-view'));
42129
+ _emberMetalDebug.assert('You tried to append to a selector string (' + selector + ') in an environment without jQuery', typeof target !== 'string');
42130
+ _emberMetalDebug.assert('You tried to append to a non-Element (' + selector + ') in an environment without jQuery', typeof selector.appendChild === 'function');
41626
42131
 
41627
- this.renderer.appendTo(this, target[0]);
42132
+ this.renderer.appendTo(this, target);
42133
+ }
41628
42134
 
41629
42135
  return this;
41630
42136
  },
@@ -41961,9 +42467,9 @@ enifed('ember-views/mixins/view_support', ['exports', 'ember-metal/debug', 'embe
41961
42467
  }, _Mixin$create.scheduleRevalidate = function (node, label, manualRerender) {
41962
42468
  if (node && !this._dispatching && this.env.renderedNodes.has(node)) {
41963
42469
  if (manualRerender) {
41964
- _emberMetalDebug.deprecate('You manually rerendered ' + label + ' (a parent component) from a child component during the rendering process. This rarely worked in Ember 1.x and will be removed in Ember 2.0', false, { id: 'ember-views.manual-parent-rerender', until: '3.0.0' });
42470
+ _emberMetalDebug.deprecate('You manually rerendered ' + label + ' (a parent component) from a child component during the rendering process. This rarely worked in Ember 1.x and will be removed in Ember 3.0', false, { id: 'ember-views.manual-parent-rerender', until: '3.0.0' });
41965
42471
  } else {
41966
- _emberMetalDebug.deprecate('You modified ' + label + ' twice in a single render. This was unreliable in Ember 1.x and will be removed in Ember 2.0', false, { id: 'ember-views.render-double-modify', until: '3.0.0' });
42472
+ _emberMetalDebug.deprecate('You modified ' + label + ' twice in a single render. This was unreliable in Ember 1.x and will be removed in Ember 3.0', false, { id: 'ember-views.render-double-modify', until: '3.0.0' });
41967
42473
  }
41968
42474
  _emberMetalRun_loop.default.scheduleOnce('render', this, this.revalidate);
41969
42475
  return;
@@ -42473,13 +42979,13 @@ enifed('ember-views/streams/utils', ['exports', 'ember-metal/debug', 'ember-meta
42473
42979
  exports.readComponentFactory = readComponentFactory;
42474
42980
  exports.readUnwrappedModel = readUnwrappedModel;
42475
42981
 
42476
- function readViewFactory(object, container) {
42982
+ function readViewFactory(object, owner) {
42477
42983
  var value = _emberMetalStreamsUtils.read(object);
42478
42984
  var viewClass;
42479
42985
 
42480
42986
  if (typeof value === 'string') {
42481
- _emberMetalDebug.assert('View requires a container to resolve views not passed in through the context', !!container);
42482
- viewClass = container.lookupFactory('view:' + value);
42987
+ _emberMetalDebug.assert('View requires an owner to resolve views not passed in through the context', !!owner);
42988
+ viewClass = owner._lookupFactory('view:' + value);
42483
42989
  } else {
42484
42990
  viewClass = value;
42485
42991
  }
@@ -42491,12 +42997,12 @@ enifed('ember-views/streams/utils', ['exports', 'ember-metal/debug', 'ember-meta
42491
42997
  return viewClass;
42492
42998
  }
42493
42999
 
42494
- function readComponentFactory(nameOrStream, container) {
43000
+ function readComponentFactory(nameOrStream, owner) {
42495
43001
  var name = _emberMetalStreamsUtils.read(nameOrStream);
42496
- var componentLookup = container.lookup('component-lookup:main');
43002
+ var componentLookup = owner.lookup('component-lookup:main');
42497
43003
  _emberMetalDebug.assert('Could not find \'component-lookup:main\' on the provided container, ' + 'which is necessary for performing component lookups', componentLookup);
42498
43004
 
42499
- return componentLookup.lookupFactory(name, container);
43005
+ return componentLookup.lookupFactory(name, owner);
42500
43006
  }
42501
43007
 
42502
43008
  function readUnwrappedModel(object) {
@@ -42845,7 +43351,7 @@ enifed('ember-views/system/build-component-template', ['exports', 'ember-metal/d
42845
43351
  })());
42846
43352
  }
42847
43353
  });
42848
- enifed('ember-views/system/event_dispatcher', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/system/jquery', 'ember-views/system/action_manager', 'ember-views/views/view', 'ember-metal/assign'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalIs_none, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsSystemJquery, _emberViewsSystemAction_manager, _emberViewsViewsView, _emberMetalAssign) {
43354
+ enifed('ember-views/system/event_dispatcher', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/is_none', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/system/jquery', 'ember-views/system/action_manager', 'ember-views/views/view', 'ember-metal/assign', 'container/owner'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalIs_none, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsSystemJquery, _emberViewsSystemAction_manager, _emberViewsViewsView, _emberMetalAssign, _containerOwner) {
42849
43355
  /**
42850
43356
  @module ember
42851
43357
  @submodule ember-views
@@ -43013,7 +43519,9 @@ enifed('ember-views/system/event_dispatcher', ['exports', 'ember-metal/debug', '
43013
43519
  */
43014
43520
  setupHandler: function (rootElement, event, eventName) {
43015
43521
  var self = this;
43016
- var viewRegistry = this.container && this.container.lookup('-view-registry:main') || _emberViewsViewsView.default.views;
43522
+
43523
+ var owner = _containerOwner.getOwner(this);
43524
+ var viewRegistry = owner && owner.lookup('-view-registry:main') || _emberViewsViewsView.default.views;
43017
43525
 
43018
43526
  if (eventName === null) {
43019
43527
  return;
@@ -43175,11 +43683,11 @@ enifed('ember-views/system/lookup_partial', ['exports', 'ember-metal/debug', 'em
43175
43683
  }
43176
43684
  _emberMetalDebug.assert('templateNames are not allowed to contain periods: ' + name, name.indexOf('.') === -1);
43177
43685
 
43178
- if (!env.container) {
43686
+ if (!env.owner) {
43179
43687
  throw new _emberMetalError.default('Container was not found when looking up a views template. ' + 'This is most likely due to manually instantiating an Ember.View. ' + 'See: http://git.io/EKPpnA');
43180
43688
  }
43181
43689
 
43182
- return env.container.lookup('template:' + underscored) || env.container.lookup('template:' + name);
43690
+ return env.owner.lookup('template:' + underscored) || env.owner.lookup('template:' + name);
43183
43691
  }
43184
43692
  });
43185
43693
  enifed('ember-views/system/platform', ['exports', 'ember-metal/environment'], function (exports, _emberMetalEnvironment) {
@@ -43311,22 +43819,17 @@ enifed('ember-views/views/checkbox', ['exports', 'ember-metal/property_get', 'em
43311
43819
  disabled: false,
43312
43820
  indeterminate: false,
43313
43821
 
43314
- init: function () {
43315
- this._super.apply(this, arguments);
43316
- this.on('change', this, this._updateElementValue);
43317
- },
43318
-
43319
43822
  didInsertElement: function () {
43320
43823
  this._super.apply(this, arguments);
43321
43824
  _emberMetalProperty_get.get(this, 'element').indeterminate = !!_emberMetalProperty_get.get(this, 'indeterminate');
43322
43825
  },
43323
43826
 
43324
- _updateElementValue: function () {
43827
+ change: function () {
43325
43828
  _emberMetalProperty_set.set(this, 'checked', this.$().prop('checked'));
43326
43829
  }
43327
43830
  });
43328
43831
  });
43329
- enifed('ember-views/views/collection_view', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-views/views/container_view', 'ember-views/views/view', 'ember-runtime/mixins/array', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/computed', 'ember-metal/mixin', 'ember-views/streams/utils', 'ember-views/mixins/empty_view_support'], function (exports, _emberMetalCore, _emberMetalDebug, _emberViewsViewsContainer_view, _emberViewsViewsView, _emberRuntimeMixinsArray, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalComputed, _emberMetalMixin, _emberViewsStreamsUtils, _emberViewsMixinsEmpty_view_support) {
43832
+ enifed('ember-views/views/collection_view', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-views/views/container_view', 'ember-views/views/view', 'ember-runtime/mixins/array', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/computed', 'ember-metal/mixin', 'ember-views/streams/utils', 'ember-views/mixins/empty_view_support', 'container/owner'], function (exports, _emberMetalCore, _emberMetalDebug, _emberViewsViewsContainer_view, _emberViewsViewsView, _emberRuntimeMixinsArray, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalComputed, _emberMetalMixin, _emberViewsStreamsUtils, _emberViewsMixinsEmpty_view_support, _containerOwner) {
43330
43833
  /**
43331
43834
  @module ember
43332
43835
  @submodule ember-views
@@ -43625,7 +44128,7 @@ enifed('ember-views/views/collection_view', ['exports', 'ember-metal/core', 'emb
43625
44128
  itemViewProps = this._itemViewProps || {};
43626
44129
  itemViewClass = this.getAttr('itemViewClass') || _emberMetalProperty_get.get(this, 'itemViewClass');
43627
44130
 
43628
- itemViewClass = _emberViewsStreamsUtils.readViewFactory(itemViewClass, this.container);
44131
+ itemViewClass = _emberViewsStreamsUtils.readViewFactory(itemViewClass, _containerOwner.getOwner(this));
43629
44132
 
43630
44133
  for (idx = start; idx < start + added; idx++) {
43631
44134
  item = content.objectAt(idx);
@@ -43780,7 +44283,7 @@ enifed('ember-views/views/collection_view', ['exports', 'ember-metal/core', 'emb
43780
44283
  enifed('ember-views/views/container_view', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-runtime/mixins/mutable_array', 'ember-runtime/system/native_array', 'ember-views/views/view', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-metal/events', 'ember-htmlbars/templates/container-view'], function (exports, _emberMetalCore, _emberMetalDebug, _emberRuntimeMixinsMutable_array, _emberRuntimeSystemNative_array, _emberViewsViewsView, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalMixin, _emberMetalEvents, _emberHtmlbarsTemplatesContainerView) {
43781
44284
  'use strict';
43782
44285
 
43783
- _emberHtmlbarsTemplatesContainerView.default.meta.revision = 'Ember@2.2.1';
44286
+ _emberHtmlbarsTemplatesContainerView.default.meta.revision = 'Ember@2.3.0-beta.1';
43784
44287
 
43785
44288
  /**
43786
44289
  @module ember
@@ -44105,7 +44608,7 @@ enifed('ember-views/views/container_view', ['exports', 'ember-metal/core', 'embe
44105
44608
 
44106
44609
  exports.default = ContainerView;
44107
44610
  });
44108
- enifed('ember-views/views/core_view', ['exports', 'ember-metal/core', 'ember-metal/debug', 'ember-metal/property_get', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/action_handler', 'ember-runtime/utils', 'ember-metal-views/renderer', 'ember-views/views/states', 'htmlbars-runtime'], function (exports, _emberMetalCore, _emberMetalDebug, _emberMetalProperty_get, _emberRuntimeSystemObject, _emberRuntimeMixinsEvented, _emberRuntimeMixinsAction_handler, _emberRuntimeUtils, _emberMetalViewsRenderer, _emberViewsViewsStates, _htmlbarsRuntime) {
44611
+ enifed('ember-views/views/core_view', ['exports', 'ember-metal/debug', 'ember-metal/property_get', 'ember-runtime/system/object', 'ember-runtime/mixins/evented', 'ember-runtime/mixins/action_handler', 'ember-runtime/utils', 'ember-metal-views/renderer', 'ember-views/views/states', 'htmlbars-runtime', 'require'], function (exports, _emberMetalDebug, _emberMetalProperty_get, _emberRuntimeSystemObject, _emberRuntimeMixinsEvented, _emberRuntimeMixinsAction_handler, _emberRuntimeUtils, _emberMetalViewsRenderer, _emberViewsViewsStates, _htmlbarsRuntime, _require) {
44109
44612
  'use strict';
44110
44613
 
44111
44614
  function K() {
@@ -44245,7 +44748,7 @@ enifed('ember-views/views/core_view', ['exports', 'ember-metal/core', 'ember-met
44245
44748
  exports.DeprecatedCoreView = DeprecatedCoreView;
44246
44749
  var _domHelper;
44247
44750
  function domHelper() {
44248
- return _domHelper = _domHelper || _emberMetalCore.default.__loader.require('ember-htmlbars/system/dom-helper')['default'];
44751
+ return _domHelper = _domHelper || _require.default('ember-htmlbars/system/dom-helper').default;
44249
44752
  }
44250
44753
 
44251
44754
  exports.default = CoreView;
@@ -45352,19 +45855,6 @@ enifed('ember-views/views/view', ['exports', 'ember-metal/core', 'ember-metal/de
45352
45855
  id: 'ember-views.view-preserves-context-flag',
45353
45856
  until: '2.0.0'
45354
45857
  });
45355
-
45356
- /**
45357
- Global hash of shared templates. This will automatically be populated
45358
- by the build tools so that you can store your Handlebars templates in
45359
- separate files that get loaded into JavaScript at buildtime.
45360
-
45361
- @property TEMPLATES
45362
- @for Ember
45363
- @type Object
45364
- @private
45365
- */
45366
- _emberMetalCore.default.TEMPLATES = {};
45367
-
45368
45858
  /**
45369
45859
  `Ember.View` is the class in Ember responsible for encapsulating templates of
45370
45860
  HTML content, combining templates with data to render as sections of a page's
@@ -49119,8 +49609,8 @@ enifed('morph-range', ['exports', 'morph-range/utils'], function (exports, _morp
49119
49609
  return this.setNode(content);
49120
49610
  }
49121
49611
  /* Handlebars.SafeString */
49122
- if (typeof content.toHTML === 'function') {
49123
- return this.setHTML(content.toHTML());
49612
+ if (typeof content.string === 'string') {
49613
+ return this.setHTML(content.string);
49124
49614
  }
49125
49615
  if (this.parseTextAsHTML) {
49126
49616
  return this.setHTML(content.toString());