ember-source 2.9.0.beta.4 → 2.9.0.beta.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: f913820221dd7bdbea11e2b615eb7dbc021029c3
4
- data.tar.gz: d457953c51f3d1e75672bfa257d5fdae5d2b6f49
3
+ metadata.gz: 24f7b5a3cd0a7ea7794bd2e33e276df9f9baf29d
4
+ data.tar.gz: 2e26ab524a5016db5414e7a46d407697c59d0229
5
5
  SHA512:
6
- metadata.gz: d3aeb492bd3a9c0cca7b7ff0a38b75bdbc465a00801b31826e63be6fa721646b563f8716c8c770c7ca2ed9133368c244075b1dd7dd19675ad59eef682ac1a0e5
7
- data.tar.gz: ef2f7b46d78c6d8862ebd1e072e1646ebce7158992b7a6d1b1de2ee71ea6d6d412d7f67edd9f73a984839968fe52a521da4c74d011bd29e599d8ec229075763c
6
+ metadata.gz: ef8e91d6d976a4f7b44563892d61afdaf0bd86611a06cc6ff2da443c0ce0c9efb31d7e34c5da7e648af2323f355a03c525a6c14ec9ea2d03d10a9b548e3bc95e
7
+ data.tar.gz: 3502263b7b8e722ed879f152adcb1bbfda1aac7f0f8f19fa342b175e683cfb000f7971e4898b3a57f486e96a6ae576697f719659deb059c7515204cf553b8bad
data/VERSION CHANGED
@@ -1 +1 @@
1
- 2.9.0-beta.4
1
+ 2.9.0-beta.5
@@ -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.9.0-beta.4
9
+ * @version 2.9.0-beta.5
10
10
  */
11
11
 
12
12
  var enifed, requireModule, require, Ember;
@@ -9726,19 +9726,12 @@ enifed('ember-metal/set_properties', ['exports', 'ember-metal/property_events',
9726
9726
  return properties;
9727
9727
  }
9728
9728
  });
9729
- enifed('ember-metal/tags', ['exports', 'ember-metal/meta', 'require'], function (exports, _emberMetalMeta, _require2) {
9729
+ enifed('ember-metal/tags', ['exports', 'glimmer-reference', 'ember-metal/meta', 'require'], function (exports, _glimmerReference, _emberMetalMeta, _require) {
9730
9730
  'use strict';
9731
9731
 
9732
9732
  exports.setHasViews = setHasViews;
9733
9733
  exports.tagFor = tagFor;
9734
-
9735
- var hasGlimmer = _require2.has('glimmer-reference');
9736
-
9737
- var CONSTANT_TAG = undefined,
9738
- CURRENT_TAG = undefined,
9739
- DirtyableTag = undefined,
9740
- makeTag = undefined,
9741
- run = undefined;
9734
+ exports.markObjectAsDirty = markObjectAsDirty;
9742
9735
 
9743
9736
  var hasViews = function () {
9744
9737
  return false;
@@ -9748,56 +9741,41 @@ enifed('ember-metal/tags', ['exports', 'ember-metal/meta', 'require'], function
9748
9741
  hasViews = fn;
9749
9742
  }
9750
9743
 
9751
- var markObjectAsDirty = undefined;
9752
-
9753
- exports.markObjectAsDirty = markObjectAsDirty;
9744
+ function makeTag() {
9745
+ return new _glimmerReference.DirtyableTag();
9746
+ }
9754
9747
 
9755
9748
  function tagFor(object, _meta) {
9756
- if (!hasGlimmer) {
9757
- throw new Error('Cannot call tagFor without Glimmer');
9758
- }
9759
-
9760
9749
  if (typeof object === 'object' && object) {
9761
9750
  var meta = _meta || _emberMetalMeta.meta(object);
9762
9751
  return meta.writableTag(makeTag);
9763
9752
  } else {
9764
- return CONSTANT_TAG;
9753
+ return _glimmerReference.CONSTANT_TAG;
9765
9754
  }
9766
9755
  }
9767
9756
 
9757
+ function markObjectAsDirty(meta) {
9758
+ var tag = meta && meta.readableTag();
9759
+
9760
+ if (tag) {
9761
+ ensureRunloop();
9762
+ tag.dirty();
9763
+ }
9764
+ }
9765
+
9766
+ var run = undefined;
9767
+
9768
9768
  function K() {}
9769
+
9769
9770
  function ensureRunloop() {
9770
9771
  if (!run) {
9771
- run = _require2.default('ember-metal/run_loop').default;
9772
+ run = _require.default('ember-metal/run_loop').default;
9772
9773
  }
9773
9774
 
9774
9775
  if (hasViews() && !run.backburner.currentInstance) {
9775
9776
  run.schedule('actions', K);
9776
9777
  }
9777
9778
  }
9778
-
9779
- if (hasGlimmer) {
9780
- var _require = _require2.default('glimmer-reference');
9781
-
9782
- DirtyableTag = _require.DirtyableTag;
9783
- CONSTANT_TAG = _require.CONSTANT_TAG;
9784
- CURRENT_TAG = _require.CURRENT_TAG;
9785
-
9786
- makeTag = function () {
9787
- return new DirtyableTag();
9788
- };
9789
-
9790
- exports.markObjectAsDirty = markObjectAsDirty = function (meta) {
9791
- var tag = meta && meta.readableTag();
9792
-
9793
- if (tag) {
9794
- ensureRunloop();
9795
- tag.dirty();
9796
- }
9797
- };
9798
- } else {
9799
- exports.markObjectAsDirty = markObjectAsDirty = function () {};
9800
- }
9801
9779
  });
9802
9780
  enifed("ember-metal/testing", ["exports"], function (exports) {
9803
9781
  "use strict";
@@ -9887,7 +9865,7 @@ enifed('ember-metal/transaction', ['exports', 'ember-metal/meta', 'ember-metal/d
9887
9865
  label = 'the same value';
9888
9866
  }
9889
9867
 
9890
- return 'You modified ' + parts.join('.') + ' twice in a single render. This was unreliable and slow in Ember 1.x and ' + implication;
9868
+ return 'You modified ' + parts.join('.') + ' twice on ' + object + ' in a single render. This was unreliable and slow in Ember 1.x and ' + implication;
9891
9869
  })(), false);
9892
9870
 
9893
9871
  shouldReflush = true;
@@ -12457,6 +12435,7 @@ enifed('ember-runtime/index', ['exports', 'ember-runtime/ext/string', 'ember-run
12457
12435
  'use strict';
12458
12436
 
12459
12437
  exports.Object = _emberRuntimeSystemObject.default;
12438
+ exports.FrameworkObject = _emberRuntimeSystemObject.FrameworkObject;
12460
12439
  exports.String = _emberRuntimeSystemString.default;
12461
12440
  exports.RegistryProxyMixin = _emberRuntimeMixinsRegistry_proxy.default;
12462
12441
  exports.buildFakeRegistryWithDeprecations = _emberRuntimeMixinsRegistry_proxy.buildFakeRegistryWithDeprecations;
@@ -12477,7 +12456,6 @@ enifed('ember-runtime/index', ['exports', 'ember-runtime/ext/string', 'ember-run
12477
12456
  exports.ArrayProxy = _emberRuntimeSystemArray_proxy.default;
12478
12457
  exports.ObjectProxy = _emberRuntimeSystemObject_proxy.default;
12479
12458
  exports.CoreObject = _emberRuntimeSystemCore_object.default;
12480
- exports.POST_INIT = _emberRuntimeSystemCore_object.POST_INIT;
12481
12459
  exports.NativeArray = _emberRuntimeSystemNative_array.default;
12482
12460
  exports.A = _emberRuntimeSystemNative_array.A;
12483
12461
  exports.ActionHandler = _emberRuntimeMixinsAction_handler.default;
@@ -12675,7 +12653,7 @@ enifed('ember-runtime/is-equal', ['exports'], function (exports) {
12675
12653
  return a === b;
12676
12654
  }
12677
12655
  });
12678
- enifed('ember-runtime/mixins/-proxy', ['exports', 'ember-utils', 'ember-metal', 'ember-runtime/computed/computed_macros', 'ember-runtime/system/core_object', 'require'], function (exports, _emberUtils, _emberMetal, _emberRuntimeComputedComputed_macros, _emberRuntimeSystemCore_object, _require2) {
12656
+ enifed('ember-runtime/mixins/-proxy', ['exports', 'glimmer-reference', 'ember-utils', 'ember-metal', 'ember-runtime/computed/computed_macros'], function (exports, _glimmerReference, _emberUtils, _emberMetal, _emberRuntimeComputedComputed_macros) {
12679
12657
  /**
12680
12658
  @module ember
12681
12659
  @submodule ember-runtime
@@ -12683,12 +12661,10 @@ enifed('ember-runtime/mixins/-proxy', ['exports', 'ember-utils', 'ember-metal',
12683
12661
 
12684
12662
  'use strict';
12685
12663
 
12686
- var _PROXY_MIXIN_PROPS;
12664
+ var _Mixin$create;
12687
12665
 
12688
12666
  exports.isProxy = isProxy;
12689
12667
 
12690
- var hasGlimmer = _require2.has('glimmer-reference');
12691
-
12692
12668
  var IS_PROXY = _emberUtils.symbol('IS_PROXY');
12693
12669
 
12694
12670
  function isProxy(value) {
@@ -12711,31 +12687,64 @@ enifed('ember-runtime/mixins/-proxy', ['exports', 'ember-utils', 'ember-metal',
12711
12687
  _emberMetal.propertyDidChange(this, key);
12712
12688
  }
12713
12689
 
12714
- /**
12715
- `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
12716
- to a proxied `content` object. See Ember.ObjectProxy for more details.
12717
-
12718
- @class ProxyMixin
12719
- @namespace Ember
12720
- @private
12721
- */
12722
- var PROXY_MIXIN_PROPS = (_PROXY_MIXIN_PROPS = {}, _PROXY_MIXIN_PROPS[IS_PROXY] = true, _PROXY_MIXIN_PROPS.content = null, _PROXY_MIXIN_PROPS._contentDidChange = _emberMetal.observer('content', function () {
12690
+ var ProxyTag = (function (_CachedTag) {
12691
+ babelHelpers.inherits(ProxyTag, _CachedTag);
12692
+
12693
+ function ProxyTag(proxy) {
12694
+ _CachedTag.call(this);
12695
+
12696
+ var content = _emberMetal.get(proxy, 'content');
12697
+
12698
+ this.proxy = proxy;
12699
+ this.proxyWrapperTag = new _glimmerReference.DirtyableTag();
12700
+ this.proxyContentTag = new _glimmerReference.UpdatableTag(_emberMetal.tagFor(content));
12701
+ }
12702
+
12703
+ /**
12704
+ `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
12705
+ to a proxied `content` object. See Ember.ObjectProxy for more details.
12706
+
12707
+ @class ProxyMixin
12708
+ @namespace Ember
12709
+ @private
12710
+ */
12711
+
12712
+ ProxyTag.prototype.compute = function compute() {
12713
+ return Math.max(this.proxyWrapperTag.value(), this.proxyContentTag.value());
12714
+ };
12715
+
12716
+ ProxyTag.prototype.dirty = function dirty() {
12717
+ this.proxyWrapperTag.dirty();
12718
+ };
12719
+
12720
+ ProxyTag.prototype.contentDidChange = function contentDidChange() {
12721
+ var content = _emberMetal.get(this.proxy, 'content');
12722
+ this.proxyContentTag.update(_emberMetal.tagFor(content));
12723
+ };
12724
+
12725
+ return ProxyTag;
12726
+ })(_glimmerReference.CachedTag);
12727
+
12728
+ exports.default = _emberMetal.Mixin.create((_Mixin$create = {}, _Mixin$create[IS_PROXY] = true, _Mixin$create.content = null, _Mixin$create._initializeTag = _emberMetal.on('init', function () {
12729
+ _emberMetal.meta(this)._tag = new ProxyTag(this);
12730
+ }), _Mixin$create._contentDidChange = _emberMetal.observer('content', function () {
12723
12731
  _emberMetal.assert('Can\'t set Proxy\'s content to itself', _emberMetal.get(this, 'content') !== this);
12724
- }), _PROXY_MIXIN_PROPS.isTruthy = _emberRuntimeComputedComputed_macros.bool('content'), _PROXY_MIXIN_PROPS._debugContainerKey = null, _PROXY_MIXIN_PROPS.willWatchProperty = function (key) {
12732
+ _emberMetal.tagFor(this).contentDidChange();
12733
+ }), _Mixin$create.isTruthy = _emberRuntimeComputedComputed_macros.bool('content'), _Mixin$create._debugContainerKey = null, _Mixin$create.willWatchProperty = function (key) {
12725
12734
  var contentKey = 'content.' + key;
12726
12735
  _emberMetal._addBeforeObserver(this, contentKey, null, contentPropertyWillChange);
12727
12736
  _emberMetal.addObserver(this, contentKey, null, contentPropertyDidChange);
12728
- }, _PROXY_MIXIN_PROPS.didUnwatchProperty = function (key) {
12737
+ }, _Mixin$create.didUnwatchProperty = function (key) {
12729
12738
  var contentKey = 'content.' + key;
12730
12739
  _emberMetal._removeBeforeObserver(this, contentKey, null, contentPropertyWillChange);
12731
12740
  _emberMetal.removeObserver(this, contentKey, null, contentPropertyDidChange);
12732
- }, _PROXY_MIXIN_PROPS.unknownProperty = function (key) {
12741
+ }, _Mixin$create.unknownProperty = function (key) {
12733
12742
  var content = _emberMetal.get(this, 'content');
12734
12743
  if (content) {
12735
12744
  _emberMetal.deprecate('You attempted to access `' + key + '` from `' + this + '`, but object proxying is deprecated. Please use `model.' + key + '` instead.', !this.isController, { id: 'ember-runtime.controller-proxy', until: '3.0.0' });
12736
12745
  return _emberMetal.get(content, key);
12737
12746
  }
12738
- }, _PROXY_MIXIN_PROPS.setUnknownProperty = function (key, value) {
12747
+ }, _Mixin$create.setUnknownProperty = function (key, value) {
12739
12748
  var m = _emberMetal.meta(this);
12740
12749
  if (m.proto === this) {
12741
12750
  // if marked as prototype then just defineProperty
@@ -12749,53 +12758,7 @@ enifed('ember-runtime/mixins/-proxy', ['exports', 'ember-utils', 'ember-metal',
12749
12758
 
12750
12759
  _emberMetal.deprecate('You attempted to set `' + key + '` from `' + this + '`, but object proxying is deprecated. Please use `model.' + key + '` instead.', !this.isController, { id: 'ember-runtime.controller-proxy', until: '3.0.0' });
12751
12760
  return _emberMetal.set(content, key, value);
12752
- }, _PROXY_MIXIN_PROPS);
12753
-
12754
- if (hasGlimmer) {
12755
- (function () {
12756
- var _require = _require2.default('glimmer-reference');
12757
-
12758
- var CachedTag = _require.CachedTag;
12759
- var DirtyableTag = _require.DirtyableTag;
12760
- var UpdatableTag = _require.UpdatableTag;
12761
-
12762
- var ProxyTag = (function (_CachedTag) {
12763
- babelHelpers.inherits(ProxyTag, _CachedTag);
12764
-
12765
- function ProxyTag(proxy, content) {
12766
- _CachedTag.call(this);
12767
- this.proxyWrapperTag = new DirtyableTag();
12768
- this.proxyContentTag = new UpdatableTag(_emberMetal.tagFor(content));
12769
- }
12770
-
12771
- ProxyTag.prototype.compute = function compute() {
12772
- return Math.max(this.proxyWrapperTag.value(), this.proxyContentTag.value());
12773
- };
12774
-
12775
- ProxyTag.prototype.dirty = function dirty() {
12776
- this.proxyWrapperTag.dirty();
12777
- };
12778
-
12779
- ProxyTag.prototype.contentDidChange = function contentDidChange(content) {
12780
- this.proxyContentTag.update(_emberMetal.tagFor(content));
12781
- };
12782
-
12783
- return ProxyTag;
12784
- })(CachedTag);
12785
-
12786
- PROXY_MIXIN_PROPS[_emberRuntimeSystemCore_object.POST_INIT] = function postInit() {
12787
- this._super();
12788
- _emberMetal.meta(this)._tag = new ProxyTag(this, _emberMetal.get(this, 'content'));
12789
- };
12790
-
12791
- PROXY_MIXIN_PROPS._contentDidChange = _emberMetal.observer('content', function () {
12792
- _emberMetal.assert('Can\'t set Proxy\'s content to itself', _emberMetal.get(this, 'content') !== this);
12793
- _emberMetal.meta(this)._tag.contentDidChange(_emberMetal.get(this, 'content'));
12794
- });
12795
- })();
12796
- }
12797
-
12798
- exports.default = _emberMetal.Mixin.create(PROXY_MIXIN_PROPS);
12761
+ }, _Mixin$create));
12799
12762
  });
12800
12763
 
12801
12764
  /**
@@ -17124,10 +17087,6 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-utils', 'ember-met
17124
17087
  // using ember-metal/lib/main here to ensure that ember-debug is setup
17125
17088
  // if present
17126
17089
 
17127
- var _Mixin$create;
17128
-
17129
- var POST_INIT = _emberUtils.symbol('POST_INIT');
17130
- exports.POST_INIT = POST_INIT;
17131
17090
  var schedule = _emberMetal.run.schedule;
17132
17091
  var applyMixin = _emberMetal.Mixin._apply;
17133
17092
  var finishPartial = _emberMetal.Mixin.finishPartial;
@@ -17234,8 +17193,6 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-utils', 'ember-met
17234
17193
 
17235
17194
  this.init.apply(this, arguments);
17236
17195
 
17237
- this[POST_INIT]();
17238
-
17239
17196
  m.proto = proto;
17240
17197
  _emberMetal.finishChains(this);
17241
17198
  _emberMetal.sendEvent(this, 'init');
@@ -17280,7 +17237,7 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-utils', 'ember-met
17280
17237
  CoreObject.toString = function () {
17281
17238
  return 'Ember.CoreObject';
17282
17239
  };
17283
- CoreObject.PrototypeMixin = _emberMetal.Mixin.create((_Mixin$create = {
17240
+ CoreObject.PrototypeMixin = _emberMetal.Mixin.create({
17284
17241
  reopen: function () {
17285
17242
  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
17286
17243
  args[_key] = arguments[_key];
@@ -17313,39 +17270,244 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-utils', 'ember-met
17313
17270
  @method init
17314
17271
  @public
17315
17272
  */
17316
- init: function () {}
17273
+ init: function () {},
17317
17274
 
17318
- }, _Mixin$create[POST_INIT] = function () {}, _Mixin$create.__defineNonEnumerable = function (property) {
17319
- Object.defineProperty(this, property.name, property.descriptor);
17320
- //this[property.name] = property.descriptor.value;
17321
- }, _Mixin$create.concatenatedProperties = null, _Mixin$create.mergedProperties = null, _Mixin$create.isDestroyed = false, _Mixin$create.isDestroying = false, _Mixin$create.destroy = function () {
17322
- if (this.isDestroying) {
17323
- return;
17324
- }
17325
- this.isDestroying = true;
17275
+ __defineNonEnumerable: function (property) {
17276
+ Object.defineProperty(this, property.name, property.descriptor);
17277
+ //this[property.name] = property.descriptor.value;
17278
+ },
17326
17279
 
17327
- schedule('actions', this, this.willDestroy);
17328
- schedule('destroy', this, this._scheduledDestroy);
17329
- return this;
17330
- }, _Mixin$create.willDestroy = function () {}, _Mixin$create._scheduledDestroy = function () {
17331
- if (this.isDestroyed) {
17332
- return;
17333
- }
17334
- _emberMetal.destroy(this);
17335
- this.isDestroyed = true;
17336
- }, _Mixin$create.bind = function (to, from) {
17337
- if (!(from instanceof _emberMetal.Binding)) {
17338
- from = _emberMetal.Binding.from(from);
17339
- }
17340
- from.to(to).connect(this);
17341
- return from;
17342
- }, _Mixin$create.toString = function () {
17343
- var hasToStringExtension = typeof this.toStringExtension === 'function';
17344
- var extension = hasToStringExtension ? ':' + this.toStringExtension() : '';
17345
- var ret = '<' + this.constructor.toString() + ':' + _emberUtils.guidFor(this) + extension + '>';
17280
+ /**
17281
+ Defines the properties that will be concatenated from the superclass
17282
+ (instead of overridden).
17283
+ By default, when you extend an Ember class a property defined in
17284
+ the subclass overrides a property with the same name that is defined
17285
+ in the superclass. However, there are some cases where it is preferable
17286
+ to build up a property's value by combining the superclass' property
17287
+ value with the subclass' value. An example of this in use within Ember
17288
+ is the `classNames` property of `Ember.View`.
17289
+ Here is some sample code showing the difference between a concatenated
17290
+ property and a normal one:
17291
+ ```javascript
17292
+ const Bar = Ember.Object.extend({
17293
+ // Configure which properties to concatenate
17294
+ concatenatedProperties: ['concatenatedProperty'],
17295
+ someNonConcatenatedProperty: ['bar'],
17296
+ concatenatedProperty: ['bar']
17297
+ });
17298
+ const FooBar = Bar.extend({
17299
+ someNonConcatenatedProperty: ['foo'],
17300
+ concatenatedProperty: ['foo']
17301
+ });
17302
+ let fooBar = FooBar.create();
17303
+ fooBar.get('someNonConcatenatedProperty'); // ['foo']
17304
+ fooBar.get('concatenatedProperty'); // ['bar', 'foo']
17305
+ ```
17306
+ This behavior extends to object creation as well. Continuing the
17307
+ above example:
17308
+ ```javascript
17309
+ let fooBar = FooBar.create({
17310
+ someNonConcatenatedProperty: ['baz'],
17311
+ concatenatedProperty: ['baz']
17312
+ })
17313
+ fooBar.get('someNonConcatenatedProperty'); // ['baz']
17314
+ fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
17315
+ ```
17316
+ Adding a single property that is not an array will just add it in the array:
17317
+ ```javascript
17318
+ let fooBar = FooBar.create({
17319
+ concatenatedProperty: 'baz'
17320
+ })
17321
+ view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
17322
+ ```
17323
+ Using the `concatenatedProperties` property, we can tell Ember to mix the
17324
+ content of the properties.
17325
+ In `Ember.Component` the `classNames`, `classNameBindings` and
17326
+ `attributeBindings` properties are concatenated.
17327
+ This feature is available for you to use throughout the Ember object model,
17328
+ although typical app developers are likely to use it infrequently. Since
17329
+ it changes expectations about behavior of properties, you should properly
17330
+ document its usage in each individual concatenated property (to not
17331
+ mislead your users to think they can override the property in a subclass).
17332
+ @property concatenatedProperties
17333
+ @type Array
17334
+ @default null
17335
+ @public
17336
+ */
17337
+ concatenatedProperties: null,
17346
17338
 
17347
- return ret;
17348
- }, _Mixin$create));
17339
+ /**
17340
+ Defines the properties that will be merged from the superclass
17341
+ (instead of overridden).
17342
+ By default, when you extend an Ember class a property defined in
17343
+ the subclass overrides a property with the same name that is defined
17344
+ in the superclass. However, there are some cases where it is preferable
17345
+ to build up a property's value by merging the superclass property value
17346
+ with the subclass property's value. An example of this in use within Ember
17347
+ is the `queryParams` property of routes.
17348
+ Here is some sample code showing the difference between a merged
17349
+ property and a normal one:
17350
+ ```javascript
17351
+ const Bar = Ember.Object.extend({
17352
+ // Configure which properties are to be merged
17353
+ mergedProperties: ['mergedProperty'],
17354
+ someNonMergedProperty: {
17355
+ nonMerged: 'superclass value of nonMerged'
17356
+ },
17357
+ mergedProperty: {
17358
+ page: {replace: false},
17359
+ limit: {replace: true}
17360
+ }
17361
+ });
17362
+ const FooBar = Bar.extend({
17363
+ someNonMergedProperty: {
17364
+ completelyNonMerged: 'subclass value of nonMerged'
17365
+ },
17366
+ mergedProperty: {
17367
+ limit: {replace: false}
17368
+ }
17369
+ });
17370
+ let fooBar = FooBar.create();
17371
+ fooBar.get('someNonMergedProperty');
17372
+ // => { completelyNonMerged: 'subclass value of nonMerged' }
17373
+ //
17374
+ // Note the entire object, including the nonMerged property of
17375
+ // the superclass object, has been replaced
17376
+ fooBar.get('mergedProperty');
17377
+ // => {
17378
+ // page: {replace: false},
17379
+ // limit: {replace: false}
17380
+ // }
17381
+ //
17382
+ // Note the page remains from the superclass, and the
17383
+ // `limit` property's value of `false` has been merged from
17384
+ // the subclass.
17385
+ ```
17386
+ This behavior is not available during object `create` calls. It is only
17387
+ available at `extend` time.
17388
+ In `Ember.Route` the `queryParams` property is merged.
17389
+ This feature is available for you to use throughout the Ember object model,
17390
+ although typical app developers are likely to use it infrequently. Since
17391
+ it changes expectations about behavior of properties, you should properly
17392
+ document its usage in each individual merged property (to not
17393
+ mislead your users to think they can override the property in a subclass).
17394
+ @property mergedProperties
17395
+ @type Array
17396
+ @default null
17397
+ @public
17398
+ */
17399
+ mergedProperties: null,
17400
+
17401
+ /**
17402
+ Destroyed object property flag.
17403
+ if this property is `true` the observers and bindings were already
17404
+ removed by the effect of calling the `destroy()` method.
17405
+ @property isDestroyed
17406
+ @default false
17407
+ @public
17408
+ */
17409
+ isDestroyed: false,
17410
+
17411
+ /**
17412
+ Destruction scheduled flag. The `destroy()` method has been called.
17413
+ The object stays intact until the end of the run loop at which point
17414
+ the `isDestroyed` flag is set.
17415
+ @property isDestroying
17416
+ @default false
17417
+ @public
17418
+ */
17419
+ isDestroying: false,
17420
+
17421
+ /**
17422
+ Destroys an object by setting the `isDestroyed` flag and removing its
17423
+ metadata, which effectively destroys observers and bindings.
17424
+ If you try to set a property on a destroyed object, an exception will be
17425
+ raised.
17426
+ Note that destruction is scheduled for the end of the run loop and does not
17427
+ happen immediately. It will set an isDestroying flag immediately.
17428
+ @method destroy
17429
+ @return {Ember.Object} receiver
17430
+ @public
17431
+ */
17432
+ destroy: function () {
17433
+ if (this.isDestroying) {
17434
+ return;
17435
+ }
17436
+ this.isDestroying = true;
17437
+
17438
+ schedule('actions', this, this.willDestroy);
17439
+ schedule('destroy', this, this._scheduledDestroy);
17440
+ return this;
17441
+ },
17442
+
17443
+ /**
17444
+ Override to implement teardown.
17445
+ @method willDestroy
17446
+ @public
17447
+ */
17448
+ willDestroy: function () {},
17449
+
17450
+ /**
17451
+ Invoked by the run loop to actually destroy the object. This is
17452
+ scheduled for execution by the `destroy` method.
17453
+ @private
17454
+ @method _scheduledDestroy
17455
+ */
17456
+ _scheduledDestroy: function () {
17457
+ if (this.isDestroyed) {
17458
+ return;
17459
+ }
17460
+ _emberMetal.destroy(this);
17461
+ this.isDestroyed = true;
17462
+ },
17463
+
17464
+ bind: function (to, from) {
17465
+ if (!(from instanceof _emberMetal.Binding)) {
17466
+ from = _emberMetal.Binding.from(from);
17467
+ }
17468
+ from.to(to).connect(this);
17469
+ return from;
17470
+ },
17471
+
17472
+ /**
17473
+ Returns a string representation which attempts to provide more information
17474
+ than Javascript's `toString` typically does, in a generic way for all Ember
17475
+ objects.
17476
+ ```javascript
17477
+ const Person = Ember.Object.extend()
17478
+ person = Person.create()
17479
+ person.toString() //=> "<Person:ember1024>"
17480
+ ```
17481
+ If the object's class is not defined on an Ember namespace, it will
17482
+ indicate it is a subclass of the registered superclass:
17483
+ ```javascript
17484
+ const Student = Person.extend()
17485
+ let student = Student.create()
17486
+ student.toString() //=> "<(subclass of Person):ember1025>"
17487
+ ```
17488
+ If the method `toStringExtension` is defined, its return value will be
17489
+ included in the output.
17490
+ ```javascript
17491
+ const Teacher = Person.extend({
17492
+ toStringExtension() {
17493
+ return this.get('fullName');
17494
+ }
17495
+ });
17496
+ teacher = Teacher.create()
17497
+ teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
17498
+ ```
17499
+ @method toString
17500
+ @return {String} string representation
17501
+ @public
17502
+ */
17503
+ toString: function () {
17504
+ var hasToStringExtension = typeof this.toStringExtension === 'function';
17505
+ var extension = hasToStringExtension ? ':' + this.toStringExtension() : '';
17506
+ var ret = '<' + this.constructor.toString() + ':' + _emberUtils.guidFor(this) + extension + '>';
17507
+
17508
+ return ret;
17509
+ }
17510
+ });
17349
17511
 
17350
17512
  CoreObject.PrototypeMixin.ownerConstructor = CoreObject;
17351
17513
 
@@ -17726,200 +17888,6 @@ enifed('ember-runtime/system/core_object', ['exports', 'ember-utils', 'ember-met
17726
17888
 
17727
17889
  exports.default = CoreObject;
17728
17890
  });
17729
-
17730
- /**
17731
- Defines the properties that will be concatenated from the superclass
17732
- (instead of overridden).
17733
- By default, when you extend an Ember class a property defined in
17734
- the subclass overrides a property with the same name that is defined
17735
- in the superclass. However, there are some cases where it is preferable
17736
- to build up a property's value by combining the superclass' property
17737
- value with the subclass' value. An example of this in use within Ember
17738
- is the `classNames` property of `Ember.View`.
17739
- Here is some sample code showing the difference between a concatenated
17740
- property and a normal one:
17741
- ```javascript
17742
- const Bar = Ember.Object.extend({
17743
- // Configure which properties to concatenate
17744
- concatenatedProperties: ['concatenatedProperty'],
17745
- someNonConcatenatedProperty: ['bar'],
17746
- concatenatedProperty: ['bar']
17747
- });
17748
- const FooBar = Bar.extend({
17749
- someNonConcatenatedProperty: ['foo'],
17750
- concatenatedProperty: ['foo']
17751
- });
17752
- let fooBar = FooBar.create();
17753
- fooBar.get('someNonConcatenatedProperty'); // ['foo']
17754
- fooBar.get('concatenatedProperty'); // ['bar', 'foo']
17755
- ```
17756
- This behavior extends to object creation as well. Continuing the
17757
- above example:
17758
- ```javascript
17759
- let fooBar = FooBar.create({
17760
- someNonConcatenatedProperty: ['baz'],
17761
- concatenatedProperty: ['baz']
17762
- })
17763
- fooBar.get('someNonConcatenatedProperty'); // ['baz']
17764
- fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
17765
- ```
17766
- Adding a single property that is not an array will just add it in the array:
17767
- ```javascript
17768
- let fooBar = FooBar.create({
17769
- concatenatedProperty: 'baz'
17770
- })
17771
- view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
17772
- ```
17773
- Using the `concatenatedProperties` property, we can tell Ember to mix the
17774
- content of the properties.
17775
- In `Ember.Component` the `classNames`, `classNameBindings` and
17776
- `attributeBindings` properties are concatenated.
17777
- This feature is available for you to use throughout the Ember object model,
17778
- although typical app developers are likely to use it infrequently. Since
17779
- it changes expectations about behavior of properties, you should properly
17780
- document its usage in each individual concatenated property (to not
17781
- mislead your users to think they can override the property in a subclass).
17782
- @property concatenatedProperties
17783
- @type Array
17784
- @default null
17785
- @public
17786
- */
17787
-
17788
- /**
17789
- Defines the properties that will be merged from the superclass
17790
- (instead of overridden).
17791
- By default, when you extend an Ember class a property defined in
17792
- the subclass overrides a property with the same name that is defined
17793
- in the superclass. However, there are some cases where it is preferable
17794
- to build up a property's value by merging the superclass property value
17795
- with the subclass property's value. An example of this in use within Ember
17796
- is the `queryParams` property of routes.
17797
- Here is some sample code showing the difference between a merged
17798
- property and a normal one:
17799
- ```javascript
17800
- const Bar = Ember.Object.extend({
17801
- // Configure which properties are to be merged
17802
- mergedProperties: ['mergedProperty'],
17803
- someNonMergedProperty: {
17804
- nonMerged: 'superclass value of nonMerged'
17805
- },
17806
- mergedProperty: {
17807
- page: {replace: false},
17808
- limit: {replace: true}
17809
- }
17810
- });
17811
- const FooBar = Bar.extend({
17812
- someNonMergedProperty: {
17813
- completelyNonMerged: 'subclass value of nonMerged'
17814
- },
17815
- mergedProperty: {
17816
- limit: {replace: false}
17817
- }
17818
- });
17819
- let fooBar = FooBar.create();
17820
- fooBar.get('someNonMergedProperty');
17821
- // => { completelyNonMerged: 'subclass value of nonMerged' }
17822
- //
17823
- // Note the entire object, including the nonMerged property of
17824
- // the superclass object, has been replaced
17825
- fooBar.get('mergedProperty');
17826
- // => {
17827
- // page: {replace: false},
17828
- // limit: {replace: false}
17829
- // }
17830
- //
17831
- // Note the page remains from the superclass, and the
17832
- // `limit` property's value of `false` has been merged from
17833
- // the subclass.
17834
- ```
17835
- This behavior is not available during object `create` calls. It is only
17836
- available at `extend` time.
17837
- In `Ember.Route` the `queryParams` property is merged.
17838
- This feature is available for you to use throughout the Ember object model,
17839
- although typical app developers are likely to use it infrequently. Since
17840
- it changes expectations about behavior of properties, you should properly
17841
- document its usage in each individual merged property (to not
17842
- mislead your users to think they can override the property in a subclass).
17843
- @property mergedProperties
17844
- @type Array
17845
- @default null
17846
- @public
17847
- */
17848
-
17849
- /**
17850
- Destroyed object property flag.
17851
- if this property is `true` the observers and bindings were already
17852
- removed by the effect of calling the `destroy()` method.
17853
- @property isDestroyed
17854
- @default false
17855
- @public
17856
- */
17857
-
17858
- /**
17859
- Destruction scheduled flag. The `destroy()` method has been called.
17860
- The object stays intact until the end of the run loop at which point
17861
- the `isDestroyed` flag is set.
17862
- @property isDestroying
17863
- @default false
17864
- @public
17865
- */
17866
-
17867
- /**
17868
- Destroys an object by setting the `isDestroyed` flag and removing its
17869
- metadata, which effectively destroys observers and bindings.
17870
- If you try to set a property on a destroyed object, an exception will be
17871
- raised.
17872
- Note that destruction is scheduled for the end of the run loop and does not
17873
- happen immediately. It will set an isDestroying flag immediately.
17874
- @method destroy
17875
- @return {Ember.Object} receiver
17876
- @public
17877
- */
17878
-
17879
- /**
17880
- Override to implement teardown.
17881
- @method willDestroy
17882
- @public
17883
- */
17884
-
17885
- /**
17886
- Invoked by the run loop to actually destroy the object. This is
17887
- scheduled for execution by the `destroy` method.
17888
- @private
17889
- @method _scheduledDestroy
17890
- */
17891
-
17892
- /**
17893
- Returns a string representation which attempts to provide more information
17894
- than Javascript's `toString` typically does, in a generic way for all Ember
17895
- objects.
17896
- ```javascript
17897
- const Person = Ember.Object.extend()
17898
- person = Person.create()
17899
- person.toString() //=> "<Person:ember1024>"
17900
- ```
17901
- If the object's class is not defined on an Ember namespace, it will
17902
- indicate it is a subclass of the registered superclass:
17903
- ```javascript
17904
- const Student = Person.extend()
17905
- let student = Student.create()
17906
- student.toString() //=> "<(subclass of Person):ember1025>"
17907
- ```
17908
- If the method `toStringExtension` is defined, its return value will be
17909
- included in the output.
17910
- ```javascript
17911
- const Teacher = Person.extend({
17912
- toStringExtension() {
17913
- return this.get('fullName');
17914
- }
17915
- });
17916
- teacher = Teacher.create()
17917
- teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
17918
- ```
17919
- @method toString
17920
- @return {String} string representation
17921
- @public
17922
- */
17923
17891
  enifed('ember-runtime/system/each_proxy', ['exports', 'ember-utils', 'ember-metal', 'ember-runtime/mixins/array'], function (exports, _emberUtils, _emberMetal, _emberRuntimeMixinsArray) {
17924
17892
  'use strict';
17925
17893
 
@@ -18503,7 +18471,7 @@ enifed('ember-runtime/system/native_array', ['exports', 'ember-metal', 'ember-en
18503
18471
  exports.default = NativeArray;
18504
18472
  });
18505
18473
  // Ember.A circular
18506
- enifed('ember-runtime/system/object', ['exports', 'ember-runtime/system/core_object', 'ember-runtime/mixins/observable'], function (exports, _emberRuntimeSystemCore_object, _emberRuntimeMixinsObservable) {
18474
+ enifed('ember-runtime/system/object', ['exports', 'ember-utils', 'ember-metal', 'ember-runtime/system/core_object', 'ember-runtime/mixins/observable'], function (exports, _emberUtils, _emberMetal, _emberRuntimeSystemCore_object, _emberRuntimeMixinsObservable) {
18507
18475
  /**
18508
18476
  @module ember
18509
18477
  @submodule ember-runtime
@@ -18527,6 +18495,26 @@ enifed('ember-runtime/system/object', ['exports', 'ember-runtime/system/core_obj
18527
18495
  return 'Ember.Object';
18528
18496
  };
18529
18497
 
18498
+ var FrameworkObject = EmberObject;
18499
+
18500
+ exports.FrameworkObject = FrameworkObject;
18501
+ _emberMetal.runInDebug(function () {
18502
+ var _EmberObject$extend;
18503
+
18504
+ var INIT_WAS_CALLED = _emberUtils.symbol('INIT_WAS_CALLED');
18505
+ var ASSERT_INIT_WAS_CALLED = _emberUtils.symbol('ASSERT_INIT_WAS_CALLED');
18506
+
18507
+ exports.FrameworkObject = FrameworkObject = EmberObject.extend((_EmberObject$extend = {
18508
+ init: function () {
18509
+ this._super.apply(this, arguments);
18510
+ this[INIT_WAS_CALLED] = true;
18511
+ }
18512
+
18513
+ }, _EmberObject$extend[ASSERT_INIT_WAS_CALLED] = _emberMetal.on('init', function () {
18514
+ _emberMetal.assert('You must call `this._super(...arguments);` when overriding `init` on a framework object. Please update ' + this + ' to call `this._super(...arguments);` from `init`.', this[INIT_WAS_CALLED]);
18515
+ }), _EmberObject$extend));
18516
+ });
18517
+
18530
18518
  exports.default = EmberObject;
18531
18519
  });
18532
18520
  enifed('ember-runtime/system/object_proxy', ['exports', 'ember-runtime/system/object', 'ember-runtime/mixins/-proxy'], function (exports, _emberRuntimeSystemObject, _emberRuntimeMixinsProxy) {
@@ -19116,7 +19104,7 @@ enifed("ember/features", ["exports"], function (exports) {
19116
19104
  enifed("ember/version", ["exports"], function (exports) {
19117
19105
  "use strict";
19118
19106
 
19119
- exports.default = "2.9.0-beta.4";
19107
+ exports.default = "2.9.0-beta.5";
19120
19108
  });
19121
19109
  /*!
19122
19110
  * @overview RSVP - a tiny implementation of Promises/A+.