ember-source 2.16.0 → 2.16.1

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: 43c8f3909c7a87a7ac1e94333fae5b3b33f5f5a0
4
- data.tar.gz: 5543b7d65d790f3d63eb3f4629065d6dc5fedf09
3
+ metadata.gz: 32904c39bf4645df84aaa32684719aca56947dfb
4
+ data.tar.gz: 45044a3f4272492ae8542a926e2418abea44518f
5
5
  SHA512:
6
- metadata.gz: 042b7c42ed44843f21d8095f2174c62f62341f9933d88162888fbcaab43dddf6d13d6ff9b6b8e4fa365ed03dc9311d3b448a01a9835246510b66e3de22ce1464
7
- data.tar.gz: 34d38a568ebaba7486f1def24a9a8b31db3476cdff1ef112fe85cd917b2e2ef2fbdb74f01ccdbed3c215df7304146ce595c0a26e1b273c057800071b6f523b66
6
+ metadata.gz: d392ac2f69a378a36ce85475a41dcff567a796e975df5c8a340ef4d43b498d78d93daa1cc11e5db118c8e1aa68d6ccb67dd387260ce00973c31b43ce0334e24d
7
+ data.tar.gz: 8b4231fbecf3a1b99c3ec9070881c4ce35dea2821eb6a8eb37943172f38d22a953b5be47813d4383872577a78c3aba49bcdd875daa0f2108226b48c94e469004
data/VERSION CHANGED
@@ -1 +1 @@
1
- 2.16.0
1
+ 2.16.1
@@ -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.16.0
9
+ * @version 2.16.1
10
10
  */
11
11
 
12
12
  var enifed, requireModule, Ember;
@@ -1396,7 +1396,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1396
1396
 
1397
1397
  /**
1398
1398
  @module ember
1399
- @submodule ember-metal
1400
1399
  */
1401
1400
 
1402
1401
  /**
@@ -1579,8 +1578,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1579
1578
  }
1580
1579
 
1581
1580
  /**
1582
- @module ember
1583
- @submodule ember-metal
1581
+ @module @ember/object
1584
1582
  */
1585
1583
  /*
1586
1584
  The event system uses a series of nested hashes to store listeners on an
@@ -1604,7 +1602,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1604
1602
  Add an event listener
1605
1603
 
1606
1604
  @method addListener
1607
- @for Ember
1605
+ @static
1606
+ @for @ember/object/events
1608
1607
  @param obj
1609
1608
  @param {String} eventName
1610
1609
  @param {Object|Function} target A target object or a function
@@ -1613,7 +1612,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1613
1612
  @public
1614
1613
  */
1615
1614
  function addListener(obj, eventName, target, method, once) {
1616
- true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to Ember.addListener', !!obj && !!eventName);
1615
+ true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to addListener', !!obj && !!eventName);
1617
1616
  true && !(eventName !== 'didInitAttrs') && emberDebug.deprecate('didInitAttrs called in ' + (obj && obj.toString && obj.toString()) + '.', eventName !== 'didInitAttrs', {
1618
1617
  id: 'ember-views.did-init-attrs',
1619
1618
  until: '3.0.0',
@@ -1640,10 +1639,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1640
1639
  /**
1641
1640
  Remove an event listener
1642
1641
 
1643
- Arguments should match those passed to `Ember.addListener`.
1642
+ Arguments should match those passed to `addListener`.
1644
1643
 
1645
1644
  @method removeListener
1646
- @for Ember
1645
+ @static
1646
+ @for @ember/object/events
1647
1647
  @param obj
1648
1648
  @param {String} eventName
1649
1649
  @param {Object|Function} target A target object or a function
@@ -1651,7 +1651,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1651
1651
  @public
1652
1652
  */
1653
1653
  function removeListener(obj, eventName, target, method) {
1654
- true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to Ember.removeListener', !!obj && !!eventName);
1654
+ true && !(!!obj && !!eventName) && emberDebug.assert('You must pass at least an object and event name to removeListener', !!obj && !!eventName);
1655
1655
 
1656
1656
  if (!method && 'function' === typeof target) {
1657
1657
  method = target;
@@ -1671,7 +1671,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1671
1671
  setting that property.
1672
1672
 
1673
1673
  @method suspendListener
1674
- @for Ember
1674
+ @static
1675
+ @for @ember/object/events
1675
1676
 
1676
1677
  @private
1677
1678
  @param obj
@@ -1688,7 +1689,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1688
1689
  Suspends multiple listeners during a callback.
1689
1690
 
1690
1691
  @method suspendListeners
1691
- @for Ember
1692
+ @static
1693
+ @for @ember/object/events
1692
1694
 
1693
1695
  @private
1694
1696
  @param obj
@@ -1710,7 +1712,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1710
1712
 
1711
1713
  @private
1712
1714
  @method watchedEvents
1713
- @for Ember
1715
+ @static
1716
+ @for @ember/object/events
1714
1717
  @param obj
1715
1718
  */
1716
1719
  function watchedEvents(obj) {
@@ -1725,7 +1728,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1725
1728
  is not passed, the actions stored on the passed object are invoked.
1726
1729
 
1727
1730
  @method sendEvent
1728
- @for Ember
1731
+ @static
1732
+ @for @ember/object/events
1729
1733
  @param obj
1730
1734
  @param {String} eventName
1731
1735
  @param {Array} params Optional parameters for each listener.
@@ -1782,7 +1786,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1782
1786
  /**
1783
1787
  @private
1784
1788
  @method hasListeners
1785
- @for Ember
1789
+ @static
1790
+ @for @ember/object/events
1786
1791
  @param obj
1787
1792
  @param {String} eventName
1788
1793
  */
@@ -1798,7 +1803,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1798
1803
  /**
1799
1804
  @private
1800
1805
  @method listenersFor
1801
- @for Ember
1806
+ @static
1807
+ @for @ember/object/events
1802
1808
  @param obj
1803
1809
  @param {String} eventName
1804
1810
  */
@@ -1826,19 +1832,24 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1826
1832
 
1827
1833
 
1828
1834
  ``` javascript
1829
- let Job = Ember.Object.extend({
1830
- logCompleted: Ember.on('completed', function() {
1835
+ import EmberObject from '@ember/object';
1836
+ import { on } from '@ember/object/evented';
1837
+ import { sendEvent } from '@ember/object/events';
1838
+
1839
+ let Job = EmberObject.extend({
1840
+ logCompleted: on('completed', function() {
1831
1841
  console.log('Job completed!');
1832
1842
  })
1833
1843
  });
1834
1844
 
1835
1845
  let job = Job.create();
1836
1846
 
1837
- Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
1847
+ sendEvent(job, 'completed'); // Logs 'Job completed!'
1838
1848
  ```
1839
1849
 
1840
1850
  @method on
1841
- @for Ember
1851
+ @static
1852
+ @for @ember/object/evented
1842
1853
  @param {String} eventNames*
1843
1854
  @param {Function} func
1844
1855
  @return func
@@ -1852,10 +1863,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
1852
1863
  var func = args.pop();
1853
1864
  var events = args;
1854
1865
 
1855
- true && !(typeof func === 'function') && emberDebug.assert('Ember.on expects function as last argument', typeof func === 'function');
1866
+ true && !(typeof func === 'function') && emberDebug.assert('on expects function as last argument', typeof func === 'function');
1856
1867
  true && !(events.length > 0 && events.every(function (p) {
1857
1868
  return typeof p === 'string' && p.length;
1858
- })) && emberDebug.assert('Ember.on called without valid event names', events.length > 0 && events.every(function (p) {
1869
+ })) && emberDebug.assert('on called without valid event names', events.length > 0 && events.every(function (p) {
1859
1870
  return typeof p === 'string' && p.length;
1860
1871
  }));
1861
1872
 
@@ -2098,6 +2109,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
2098
2109
  };
2099
2110
  }
2100
2111
 
2112
+ /**
2113
+ @module ember
2114
+ @private
2115
+ */
2116
+
2101
2117
  var PROPERTY_DID_CHANGE = emberUtils.symbol('PROPERTY_DID_CHANGE');
2102
2118
 
2103
2119
  var beforeObserverSet = new ObserverSet();
@@ -2406,7 +2422,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
2406
2422
  }
2407
2423
 
2408
2424
  /**
2409
- @module ember-metal
2425
+ @module @ember/object
2410
2426
  */
2411
2427
 
2412
2428
  // ..........................................................
@@ -2450,7 +2466,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
2450
2466
  if (!m.isInitialized(this)) {
2451
2467
  m.writeValues(name, value);
2452
2468
  } else {
2453
- true && !false && emberDebug.assert('You must use Ember.set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false);
2469
+ true && !false && emberDebug.assert('You must use set() to set the `' + name + '` property (of ' + this + ') to `' + value + '`.', false);
2454
2470
  }
2455
2471
  }
2456
2472
 
@@ -2490,7 +2506,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
2490
2506
  /**
2491
2507
  NOTE: This is a low-level method used by other parts of the API. You almost
2492
2508
  never want to call this method directly. Instead you should use
2493
- `Ember.mixin()` to define new properties.
2509
+ `mixin()` to define new properties.
2494
2510
 
2495
2511
  Defines a property on an object. This method works much like the ES5
2496
2512
  `Object.defineProperty()` method except that it can also accept computed
@@ -2504,8 +2520,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
2504
2520
  ## Examples
2505
2521
 
2506
2522
  ```javascript
2523
+ import { defineProperty, computed } from '@ember/object';
2524
+
2507
2525
  // ES5 compatible mode
2508
- Ember.defineProperty(contact, 'firstName', {
2526
+ defineProperty(contact, 'firstName', {
2509
2527
  writable: true,
2510
2528
  configurable: false,
2511
2529
  enumerable: true,
@@ -2513,17 +2531,17 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
2513
2531
  });
2514
2532
 
2515
2533
  // define a simple property
2516
- Ember.defineProperty(contact, 'lastName', undefined, 'Jolley');
2534
+ defineProperty(contact, 'lastName', undefined, 'Jolley');
2517
2535
 
2518
2536
  // define a computed property
2519
- Ember.defineProperty(contact, 'fullName', Ember.computed('firstName', 'lastName', function() {
2537
+ defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
2520
2538
  return this.firstName+' '+this.lastName;
2521
2539
  }));
2522
2540
  ```
2523
2541
 
2524
2542
  @private
2525
2543
  @method defineProperty
2526
- @for Ember
2544
+ @for @ember/object
2527
2545
  @param {Object} obj the object to define this property on. This may be a prototype.
2528
2546
  @param {String} keyName the name of the property
2529
2547
  @param {Descriptor} [desc] an instance of `Descriptor` (typically a
@@ -3191,7 +3209,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
3191
3209
  }
3192
3210
 
3193
3211
  /**
3194
- @module ember-metal
3212
+ @module ember
3195
3213
  */
3196
3214
 
3197
3215
  var UNDEFINED = emberUtils.symbol('undefined');
@@ -3905,7 +3923,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
3905
3923
  }
3906
3924
 
3907
3925
  /**
3908
- @module ember-metal
3926
+ @module @ember/object
3909
3927
  */
3910
3928
 
3911
3929
  var ALLOWABLE_TYPES = {
@@ -3944,7 +3962,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
3944
3962
  an error.
3945
3963
 
3946
3964
  @method get
3947
- @for Ember
3965
+ @for @ember/object
3966
+ @static
3948
3967
  @param {Object} obj The object to retrieve from.
3949
3968
  @param {String} keyName The property key to retrieve
3950
3969
  @return {Object} the property value or `null`.
@@ -4003,7 +4022,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4003
4022
  ```
4004
4023
 
4005
4024
  @method getWithDefault
4006
- @for Ember
4025
+ @for @ember/object
4026
+ @static
4007
4027
  @param {Object} obj The object to retrieve from.
4008
4028
  @param {String} keyName The name of the property to retrieve
4009
4029
  @param {Object} defaultValue The value to return if the property value is undefined
@@ -4019,6 +4039,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4019
4039
  return value;
4020
4040
  }
4021
4041
 
4042
+ /**
4043
+ @module @ember/object
4044
+ */
4022
4045
  /**
4023
4046
  Sets the value of a property on an object, respecting computed properties
4024
4047
  and notifying observers and other listeners of the change. If the
@@ -4030,7 +4053,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4030
4053
  ```
4031
4054
 
4032
4055
  @method set
4033
- @for Ember
4056
+ @static
4057
+ @for @ember/object
4034
4058
  @param {Object} obj The object to modify.
4035
4059
  @param {String} keyName The property key to set
4036
4060
  @param {Object} value The value to set
@@ -4119,7 +4143,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4119
4143
  an object has been destroyed.
4120
4144
 
4121
4145
  @method trySet
4122
- @for Ember
4146
+ @static
4147
+ @for @ember/object
4123
4148
  @param {Object} root The object to modify.
4124
4149
  @param {String} path The property path to set
4125
4150
  @param {Object} value The value to set
@@ -4130,8 +4155,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4130
4155
  }
4131
4156
 
4132
4157
  /**
4133
- @module ember
4134
- @submodule ember-metal
4158
+ @module @ember/object
4135
4159
  */
4136
4160
 
4137
4161
  var END_WITH_EACH_REGEX = /\.@each$/;
@@ -4145,19 +4169,22 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4145
4169
  Example
4146
4170
 
4147
4171
  ```js
4172
+ import { expandProperties } from '@ember/object/computed';
4173
+
4148
4174
  function echo(arg){ console.log(arg); }
4149
4175
 
4150
- Ember.expandProperties('foo.bar', echo); //=> 'foo.bar'
4151
- Ember.expandProperties('{foo,bar}', echo); //=> 'foo', 'bar'
4152
- Ember.expandProperties('foo.{bar,baz}', echo); //=> 'foo.bar', 'foo.baz'
4153
- Ember.expandProperties('{foo,bar}.baz', echo); //=> 'foo.baz', 'bar.baz'
4154
- Ember.expandProperties('foo.{bar,baz}.[]', echo) //=> 'foo.bar.[]', 'foo.baz.[]'
4155
- Ember.expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
4156
- Ember.expandProperties('{foo}.bar.{baz}') //=> 'foo.bar.baz'
4176
+ expandProperties('foo.bar', echo); //=> 'foo.bar'
4177
+ expandProperties('{foo,bar}', echo); //=> 'foo', 'bar'
4178
+ expandProperties('foo.{bar,baz}', echo); //=> 'foo.bar', 'foo.baz'
4179
+ expandProperties('{foo,bar}.baz', echo); //=> 'foo.baz', 'bar.baz'
4180
+ expandProperties('foo.{bar,baz}.[]', echo) //=> 'foo.bar.[]', 'foo.baz.[]'
4181
+ expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
4182
+ expandProperties('{foo}.bar.{baz}') //=> 'foo.bar.baz'
4157
4183
  ```
4158
4184
 
4159
4185
  @method expandProperties
4160
- @for Ember
4186
+ @static
4187
+ @for @ember/object
4161
4188
  @public
4162
4189
  @param {String} pattern The property pattern to expand.
4163
4190
  @param {Function} callback The callback to invoke. It is invoked once per
@@ -4199,7 +4226,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4199
4226
  }
4200
4227
 
4201
4228
  /**
4202
- @module ember-metal
4229
+ @module ember
4203
4230
  */
4204
4231
  /**
4205
4232
  Starts watching a property on an object. Whenever the property changes,
@@ -4239,11 +4266,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4239
4266
  }
4240
4267
  }
4241
4268
 
4242
- /**
4243
- @module ember
4244
- @submodule ember-metal
4245
- */
4246
-
4247
4269
  // ..........................................................
4248
4270
  // DEPENDENT KEYS
4249
4271
  //
@@ -4283,8 +4305,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4283
4305
  }
4284
4306
 
4285
4307
  /**
4286
- @module ember
4287
- @submodule ember-metal
4308
+ @module @ember/object
4288
4309
  */
4289
4310
 
4290
4311
  var DEEP_EACH_REGEX = /\.@each\.[^.]+\./;
@@ -4298,23 +4319,25 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4298
4319
  result to be recomputed if the dependencies are modified.
4299
4320
 
4300
4321
  In the following example we declare a computed property - `fullName` - by calling
4301
- `.Ember.computed()` with property dependencies (`firstName` and `lastName`) as leading arguments and getter accessor function. The `fullName` getter function
4322
+ `computed` with property dependencies (`firstName` and `lastName`) as leading arguments and getter accessor function. The `fullName` getter function
4302
4323
  will be called once (regardless of how many times it is accessed) as long
4303
4324
  as its dependencies have not changed. Once `firstName` or `lastName` are updated
4304
4325
  any future calls (or anything bound) to `fullName` will incorporate the new
4305
4326
  values.
4306
4327
 
4307
4328
  ```javascript
4308
- let Person = Ember.Object.extend({
4329
+ import EmberObject, { computed } from '@ember/object';
4330
+
4331
+ let Person = EmberObject.extend({
4309
4332
  // these will be supplied by `create`
4310
4333
  firstName: null,
4311
4334
  lastName: null,
4312
4335
 
4313
- fullName: Ember.computed('firstName', 'lastName', function() {
4336
+ fullName: computed('firstName', 'lastName', function() {
4314
4337
  let firstName = this.get('firstName'),
4315
4338
  lastName = this.get('lastName');
4316
4339
 
4317
- return firstName + ' ' + lastName;
4340
+ return `${firstName} ${lastName}`;
4318
4341
  })
4319
4342
  });
4320
4343
 
@@ -4331,12 +4354,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4331
4354
  value you want to set it to as arguments.
4332
4355
 
4333
4356
  ```javascript
4334
- let Person = Ember.Object.extend({
4357
+ import EmberObject, { computed } from '@ember/object';
4358
+
4359
+ let Person = EmberObject.extend({
4335
4360
  // these will be supplied by `create`
4336
4361
  firstName: null,
4337
4362
  lastName: null,
4338
4363
 
4339
- fullName: Ember.computed('firstName', 'lastName', {
4364
+ fullName: computed('firstName', 'lastName', {
4340
4365
  get(key) {
4341
4366
  let firstName = this.get('firstName'),
4342
4367
  lastName = this.get('lastName');
@@ -4366,12 +4391,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4366
4391
  You can also mark computed property as `.readOnly()` and block all attempts to set it.
4367
4392
 
4368
4393
  ```javascript
4369
- let Person = Ember.Object.extend({
4394
+ import EmberObject, { computed } from '@ember/object';
4395
+
4396
+ let Person = EmberObject.extend({
4370
4397
  // these will be supplied by `create`
4371
4398
  firstName: null,
4372
4399
  lastName: null,
4373
4400
 
4374
- fullName: Ember.computed('firstName', 'lastName', {
4401
+ fullName: computed('firstName', 'lastName', {
4375
4402
  get(key) {
4376
4403
  let firstName = this.get('firstName');
4377
4404
  let lastName = this.get('lastName');
@@ -4390,7 +4417,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4390
4417
  - [New computed syntax explained in "Ember 1.12 released" ](https://emberjs.com/blog/2015/05/13/ember-1-12-released.html#toc_new-computed-syntax)
4391
4418
 
4392
4419
  @class ComputedProperty
4393
- @namespace Ember
4394
4420
  @public
4395
4421
  */
4396
4422
  function ComputedProperty(config, opts) {
@@ -4399,10 +4425,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4399
4425
  if (hasGetterOnly) {
4400
4426
  this._getter = config;
4401
4427
  } else {
4402
- true && !(typeof config === 'object' && !Array.isArray(config)) && emberDebug.assert('Ember.computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
4428
+ true && !(typeof config === 'object' && !Array.isArray(config)) && emberDebug.assert('computed expects a function or an object as last argument.', typeof config === 'object' && !Array.isArray(config));
4403
4429
  true && !Object.keys(config).every(function (key) {
4404
4430
  return key === 'get' || key === 'set';
4405
- }) && emberDebug.assert('Config object passed to an Ember.computed can only contain `get` or `set` keys.', Object.keys(config).every(function (key) {
4431
+ }) && emberDebug.assert('Config object passed to computed can only contain `get` or `set` keys.', Object.keys(config).every(function (key) {
4406
4432
  return key === 'get' || key === 'set';
4407
4433
  }));
4408
4434
 
@@ -4435,15 +4461,19 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4435
4461
  invalidation and notification when cached value is invalidated.
4436
4462
 
4437
4463
  ```javascript
4438
- let outsideService = Ember.Object.extend({
4439
- value: Ember.computed(function() {
4464
+ import EmberObject, { computed } from '@ember/object';
4465
+
4466
+ let outsideService = EmberObject.extend({
4467
+ value: computed(function() {
4440
4468
  return OutsideService.getValue();
4441
4469
  }).volatile()
4442
4470
  }).create();
4443
4471
  ```
4444
4472
 
4445
4473
  @method volatile
4446
- @return {Ember.ComputedProperty} this
4474
+ @static
4475
+ @for @ember/object/computed
4476
+ @return {ComputedProperty} this
4447
4477
  @chainable
4448
4478
  @public
4449
4479
  */
@@ -4457,8 +4487,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4457
4487
  mode the computed property will throw an error when set.
4458
4488
 
4459
4489
  ```javascript
4460
- let Person = Ember.Object.extend({
4461
- guid: Ember.computed(function() {
4490
+ import EmberObject, { computed } from '@ember/object';
4491
+
4492
+ let Person = EmberObject.extend({
4493
+ guid: computed(function() {
4462
4494
  return 'guid-guid-guid';
4463
4495
  }).readOnly()
4464
4496
  });
@@ -4469,7 +4501,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4469
4501
  ```
4470
4502
 
4471
4503
  @method readOnly
4472
- @return {Ember.ComputedProperty} this
4504
+ @static
4505
+ @for @ember/object/computed
4506
+ @return {ComputedProperty} this
4473
4507
  @chainable
4474
4508
  @public
4475
4509
  */
@@ -4485,13 +4519,15 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4485
4519
  arguments containing key paths that this computed property depends on.
4486
4520
 
4487
4521
  ```javascript
4488
- let President = Ember.Object.extend({
4489
- fullName: Ember.computed(function() {
4522
+ import EmberObject, { computed } from '@ember/object';
4523
+
4524
+ let President = EmberObject.extend({
4525
+ fullName: computed('firstName', 'lastName', function() {
4490
4526
  return this.get('firstName') + ' ' + this.get('lastName');
4491
4527
 
4492
4528
  // Tell Ember that this computed property depends on firstName
4493
4529
  // and lastName
4494
- }).property('firstName', 'lastName')
4530
+ })
4495
4531
  });
4496
4532
 
4497
4533
  let president = President.create({
@@ -4503,8 +4539,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4503
4539
  ```
4504
4540
 
4505
4541
  @method property
4542
+ @static
4543
+ @for @ember/object/computed
4506
4544
  @param {String} path* zero or more property paths
4507
- @return {Ember.ComputedProperty} this
4545
+ @return {ComputedProperty} this
4508
4546
  @chainable
4509
4547
  @public
4510
4548
  */
@@ -4549,6 +4587,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4549
4587
  via the `metaForProperty()` function.
4550
4588
 
4551
4589
  @method meta
4590
+ @static
4591
+ @for @ember/object/computed
4552
4592
  @param {Object} meta
4553
4593
  @chainable
4554
4594
  @public
@@ -4705,13 +4745,15 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4705
4745
  /**
4706
4746
  This helper returns a new property descriptor that wraps the passed
4707
4747
  computed property function. You can use this helper to define properties
4708
- with mixins or via `Ember.defineProperty()`.
4748
+ with mixins or via `defineProperty()`.
4709
4749
 
4710
4750
  If you pass a function as an argument, it will be used as a getter. A computed
4711
4751
  property defined in this way might look like this:
4712
4752
 
4713
4753
  ```js
4714
- let Person = Ember.Object.extend({
4754
+ import EmberObject, { computed } from '@ember/object';
4755
+
4756
+ let Person = EmberObject.extend({
4715
4757
  init() {
4716
4758
  this._super(...arguments);
4717
4759
 
@@ -4719,7 +4761,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4719
4761
  this.lastName = 'Jones';
4720
4762
  },
4721
4763
 
4722
- fullName: Ember.computed('firstName', 'lastName', function() {
4764
+ fullName: computed('firstName', 'lastName', function() {
4723
4765
  return `${this.get('firstName')} ${this.get('lastName')}`;
4724
4766
  })
4725
4767
  });
@@ -4736,7 +4778,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4736
4778
  argument to provide both a getter and setter:
4737
4779
 
4738
4780
  ```js
4739
- let Person = Ember.Object.extend({
4781
+ import EmberObject, { computed } from '@ember/object';
4782
+
4783
+ let Person = EmberObject.extend({
4740
4784
  init() {
4741
4785
  this._super(...arguments);
4742
4786
 
@@ -4744,7 +4788,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4744
4788
  this.lastName = 'Jones';
4745
4789
  },
4746
4790
 
4747
- fullName: Ember.computed('firstName', 'lastName', {
4791
+ fullName: computed('firstName', 'lastName', {
4748
4792
  get(key) {
4749
4793
  return `${this.get('firstName')} ${this.get('lastName')}`;
4750
4794
  },
@@ -4778,13 +4822,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4778
4822
  }.property('firstName', 'lastName')
4779
4823
  ```
4780
4824
 
4781
- @class computed
4782
- @namespace Ember
4783
- @constructor
4825
+ @method computed
4826
+ @for @ember/object
4784
4827
  @static
4785
4828
  @param {String} [dependentKeys*] Optional dependent keys that trigger this computed property.
4786
4829
  @param {Function} func The computed property function.
4787
- @return {Ember.ComputedProperty} property descriptor instance
4830
+ @return {ComputedProperty} property descriptor instance
4788
4831
  @public
4789
4832
  */
4790
4833
  function computed() {
@@ -4810,7 +4853,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4810
4853
  it to be created.
4811
4854
 
4812
4855
  @method cacheFor
4813
- @for Ember
4856
+ @static
4857
+ @for @ember/object/internals
4814
4858
  @param {Object} obj the object whose property you want to check
4815
4859
  @param {String} key the name of the property whose cached value you want
4816
4860
  to return
@@ -4932,18 +4976,24 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4932
4976
  AliasedProperty.prototype._meta = undefined;
4933
4977
  AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;
4934
4978
 
4979
+ /**
4980
+ @module @ember/polyfills
4981
+ */
4935
4982
  /**
4936
4983
  Merge the contents of two objects together into the first object.
4937
4984
 
4938
4985
  ```javascript
4939
- Ember.merge({ first: 'Tom' }, { last: 'Dale' }); // { first: 'Tom', last: 'Dale' }
4986
+ import { merge } from '@ember/polyfills';
4987
+
4988
+ merge({ first: 'Tom' }, { last: 'Dale' }); // { first: 'Tom', last: 'Dale' }
4940
4989
  var a = { first: 'Yehuda' };
4941
4990
  var b = { last: 'Katz' };
4942
- Ember.merge(a, b); // a == { first: 'Yehuda', last: 'Katz' }, b == { last: 'Katz' }
4991
+ merge(a, b); // a == { first: 'Yehuda', last: 'Katz' }, b == { last: 'Katz' }
4943
4992
  ```
4944
4993
 
4945
4994
  @method merge
4946
- @for Ember
4995
+ @static
4996
+ @for @ember/polyfills
4947
4997
  @param {Object} original The object to merge into
4948
4998
  @param {Object} updates The object to copy properties from
4949
4999
  @return {Object}
@@ -4967,7 +5017,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
4967
5017
 
4968
5018
  /**
4969
5019
  @module ember
4970
- @submodule ember-metal
4971
5020
  */
4972
5021
 
4973
5022
  /**
@@ -5004,15 +5053,22 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5004
5053
  /* eslint no-console:off */
5005
5054
  /* global console */
5006
5055
 
5056
+ /**
5057
+ @module @ember/instrumentation
5058
+ @private
5059
+ */
5060
+
5007
5061
  /**
5008
5062
  The purpose of the Ember Instrumentation module is
5009
5063
  to provide efficient, general-purpose instrumentation
5010
5064
  for Ember.
5011
5065
 
5012
- Subscribe to a listener by using `Ember.subscribe`:
5066
+ Subscribe to a listener by using `subscribe`:
5013
5067
 
5014
5068
  ```javascript
5015
- Ember.subscribe("render", {
5069
+ import { subscribe } from '@ember/instrumentation';
5070
+
5071
+ subscribe("render", {
5016
5072
  before(name, timestamp, payload) {
5017
5073
 
5018
5074
  },
@@ -5027,15 +5083,17 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5027
5083
  value will be passed as a fourth parameter to the `after`
5028
5084
  callback.
5029
5085
 
5030
- Instrument a block of code by using `Ember.instrument`:
5086
+ Instrument a block of code by using `instrument`:
5031
5087
 
5032
5088
  ```javascript
5033
- Ember.instrument("render.handlebars", payload, function() {
5089
+ import { instrument } from '@ember/instrumentation';
5090
+
5091
+ instrument("render.handlebars", payload, function() {
5034
5092
  // rendering logic
5035
5093
  }, binding);
5036
5094
  ```
5037
5095
 
5038
- Event names passed to `Ember.instrument` are namespaced
5096
+ Event names passed to `instrument` are namespaced
5039
5097
  by periods, from more general to more specific. Subscribers
5040
5098
  can listen for events by whatever level of granularity they
5041
5099
  are interested in.
@@ -5047,7 +5105,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5047
5105
  even `render.handlebars.layout`.
5048
5106
 
5049
5107
  @class Instrumentation
5050
- @namespace Ember
5051
5108
  @static
5052
5109
  @private
5053
5110
  */
@@ -5082,8 +5139,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5082
5139
  Notifies event's subscribers, calls `before` and `after` hooks.
5083
5140
 
5084
5141
  @method instrument
5085
- @namespace Ember.Instrumentation
5086
-
5142
+ @for @ember/instrumentation
5143
+ @static
5087
5144
  @param {String} [name] Namespaced event name.
5088
5145
  @param {Object} _payload
5089
5146
  @param {Function} callback Function that you're instrumenting.
@@ -5189,7 +5246,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5189
5246
  Subscribes to a particular event or instrumented block of code.
5190
5247
 
5191
5248
  @method subscribe
5192
- @namespace Ember.Instrumentation
5249
+ @for @ember/instrumentation
5250
+ @static
5193
5251
 
5194
5252
  @param {String} [pattern] Namespaced event name.
5195
5253
  @param {Object} [object] Before and After hooks.
@@ -5230,7 +5288,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5230
5288
  Unsubscribes from a particular event or instrumented block of code.
5231
5289
 
5232
5290
  @method unsubscribe
5233
- @namespace Ember.Instrumentation
5291
+ @for @ember/instrumentation
5292
+ @static
5234
5293
 
5235
5294
  @param {Object} [subscriber]
5236
5295
  @private
@@ -5249,10 +5308,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5249
5308
  }
5250
5309
 
5251
5310
  /**
5252
- Resets `Ember.Instrumentation` by flushing list of subscribers.
5311
+ Resets `Instrumentation` by flushing list of subscribers.
5253
5312
 
5254
5313
  @method reset
5255
- @namespace Ember.Instrumentation
5314
+ @for @ember/instrumentation
5315
+ @static
5256
5316
  @private
5257
5317
  */
5258
5318
  function reset() {
@@ -5317,6 +5377,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5317
5377
  }
5318
5378
  }
5319
5379
 
5380
+ /**
5381
+ @module ember
5382
+ */
5320
5383
  var id = 0;
5321
5384
 
5322
5385
  // Returns whether Type(value) is Object according to the terminology in the spec
@@ -5454,22 +5517,26 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5454
5517
 
5455
5518
  var weak_map = emberUtils.HAS_NATIVE_WEAKMAP ? WeakMap : WeakMapPolyfill;
5456
5519
 
5520
+ /**
5521
+ @module @ember/utils
5522
+ */
5457
5523
  /**
5458
5524
  Returns true if the passed value is null or undefined. This avoids errors
5459
5525
  from JSLint complaining about use of ==, which can be technically
5460
5526
  confusing.
5461
5527
 
5462
5528
  ```javascript
5463
- Ember.isNone(); // true
5464
- Ember.isNone(null); // true
5465
- Ember.isNone(undefined); // true
5466
- Ember.isNone(''); // false
5467
- Ember.isNone([]); // false
5468
- Ember.isNone(function() {}); // false
5529
+ isNone(); // true
5530
+ isNone(null); // true
5531
+ isNone(undefined); // true
5532
+ isNone(''); // false
5533
+ isNone([]); // false
5534
+ isNone(function() {}); // false
5469
5535
  ```
5470
5536
 
5471
5537
  @method isNone
5472
- @for Ember
5538
+ @static
5539
+ @for @ember/utils
5473
5540
  @param {Object} obj Value to test
5474
5541
  @return {Boolean}
5475
5542
  @public
@@ -5478,28 +5545,32 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5478
5545
  return obj === null || obj === undefined;
5479
5546
  }
5480
5547
 
5548
+ /**
5549
+ @module @ember/utils
5550
+ */
5481
5551
  /**
5482
5552
  Verifies that a value is `null` or `undefined`, an empty string, or an empty
5483
5553
  array.
5484
5554
 
5485
- Constrains the rules on `Ember.isNone` by returning true for empty strings and
5555
+ Constrains the rules on `isNone` by returning true for empty strings and
5486
5556
  empty arrays.
5487
5557
 
5488
5558
  ```javascript
5489
- Ember.isEmpty(); // true
5490
- Ember.isEmpty(null); // true
5491
- Ember.isEmpty(undefined); // true
5492
- Ember.isEmpty(''); // true
5493
- Ember.isEmpty([]); // true
5494
- Ember.isEmpty({}); // false
5495
- Ember.isEmpty('Adam Hawkins'); // false
5496
- Ember.isEmpty([0,1,2]); // false
5497
- Ember.isEmpty('\n\t'); // false
5498
- Ember.isEmpty(' '); // false
5559
+ isEmpty(); // true
5560
+ isEmpty(null); // true
5561
+ isEmpty(undefined); // true
5562
+ isEmpty(''); // true
5563
+ isEmpty([]); // true
5564
+ isEmpty({}); // false
5565
+ isEmpty('Adam Hawkins'); // false
5566
+ isEmpty([0,1,2]); // false
5567
+ isEmpty('\n\t'); // false
5568
+ isEmpty(' '); // false
5499
5569
  ```
5500
5570
 
5501
5571
  @method isEmpty
5502
- @for Ember
5572
+ @static
5573
+ @for @ember/utils
5503
5574
  @param {Object} obj Value to test
5504
5575
  @return {Boolean}
5505
5576
  @public
@@ -5537,25 +5608,31 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5537
5608
  return false;
5538
5609
  }
5539
5610
 
5611
+ /**
5612
+ @module @ember/utils
5613
+ */
5540
5614
  /**
5541
5615
  A value is blank if it is empty or a whitespace string.
5542
5616
 
5543
5617
  ```javascript
5544
- Ember.isBlank(); // true
5545
- Ember.isBlank(null); // true
5546
- Ember.isBlank(undefined); // true
5547
- Ember.isBlank(''); // true
5548
- Ember.isBlank([]); // true
5549
- Ember.isBlank('\n\t'); // true
5550
- Ember.isBlank(' '); // true
5551
- Ember.isBlank({}); // false
5552
- Ember.isBlank('\n\t Hello'); // false
5553
- Ember.isBlank('Hello world'); // false
5554
- Ember.isBlank([1,2,3]); // false
5618
+ import { isBlank } from '@ember/utils';
5619
+
5620
+ isBlank(); // true
5621
+ isBlank(null); // true
5622
+ isBlank(undefined); // true
5623
+ isBlank(''); // true
5624
+ isBlank([]); // true
5625
+ isBlank('\n\t'); // true
5626
+ isBlank(' '); // true
5627
+ isBlank({}); // false
5628
+ isBlank('\n\t Hello'); // false
5629
+ isBlank('Hello world'); // false
5630
+ isBlank([1,2,3]); // false
5555
5631
  ```
5556
5632
 
5557
5633
  @method isBlank
5558
- @for Ember
5634
+ @static
5635
+ @for @ember/utils
5559
5636
  @param {Object} obj Value to test
5560
5637
  @return {Boolean}
5561
5638
  @since 1.5.0
@@ -5565,31 +5642,35 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5565
5642
  return isEmpty(obj) || typeof obj === 'string' && /\S/.test(obj) === false;
5566
5643
  }
5567
5644
 
5645
+ /**
5646
+ @module @ember/utils
5647
+ */
5568
5648
  /**
5569
5649
  A value is present if it not `isBlank`.
5570
5650
 
5571
5651
  ```javascript
5572
- Ember.isPresent(); // false
5573
- Ember.isPresent(null); // false
5574
- Ember.isPresent(undefined); // false
5575
- Ember.isPresent(''); // false
5576
- Ember.isPresent(' '); // false
5577
- Ember.isPresent('\n\t'); // false
5578
- Ember.isPresent([]); // false
5579
- Ember.isPresent({ length: 0 }) // false
5580
- Ember.isPresent(false); // true
5581
- Ember.isPresent(true); // true
5582
- Ember.isPresent('string'); // true
5583
- Ember.isPresent(0); // true
5584
- Ember.isPresent(function() {}) // true
5585
- Ember.isPresent({}); // true
5586
- Ember.isPresent(false); // true
5587
- Ember.isPresent('\n\t Hello'); // true
5588
- Ember.isPresent([1,2,3]); // true
5652
+ isPresent(); // false
5653
+ isPresent(null); // false
5654
+ isPresent(undefined); // false
5655
+ isPresent(''); // false
5656
+ isPresent(' '); // false
5657
+ isPresent('\n\t'); // false
5658
+ isPresent([]); // false
5659
+ isPresent({ length: 0 }) // false
5660
+ isPresent(false); // true
5661
+ isPresent(true); // true
5662
+ isPresent('string'); // true
5663
+ isPresent(0); // true
5664
+ isPresent(function() {}) // true
5665
+ isPresent({}); // true
5666
+ isPresent(false); // true
5667
+ isPresent('\n\t Hello'); // true
5668
+ isPresent([1,2,3]); // true
5589
5669
  ```
5590
5670
 
5591
5671
  @method isPresent
5592
- @for Ember
5672
+ @static
5673
+ @for @ember/utils
5593
5674
  @param {Object} obj Value to test
5594
5675
  @return {Boolean}
5595
5676
  @since 1.8.0
@@ -5620,6 +5701,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5620
5701
  onErrorMethod: 'onerror'
5621
5702
  });
5622
5703
 
5704
+ /**
5705
+ @module @ember/runloop
5706
+ */
5623
5707
  // ..........................................................
5624
5708
  // run - this is ideally the only public API the dev sees
5625
5709
  //
@@ -5640,8 +5724,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5640
5724
  });
5641
5725
  ```
5642
5726
 
5643
- @class run
5644
- @namespace Ember
5727
+ @class @ember/runloop
5645
5728
  @static
5646
5729
  @constructor
5647
5730
  @param {Object} [target] target of method to call
@@ -5684,7 +5767,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5684
5767
  ```
5685
5768
 
5686
5769
  @method join
5687
- @namespace Ember
5770
+ @static
5771
+ @for @ember/runloop
5688
5772
  @param {Object} [target] target of method to call
5689
5773
  @param {Function|String} method Method to invoke.
5690
5774
  May be a function or a string. If you pass a string
@@ -5748,7 +5832,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5748
5832
  method be safely handled and executed by the Ember run loop.
5749
5833
 
5750
5834
  @method bind
5751
- @namespace Ember
5835
+ @static
5836
+ @for @ember/runloop
5752
5837
  @param {Object} [target] target of method to call
5753
5838
  @param {Function|String} method Method to invoke.
5754
5839
  May be a function or a string. If you pass a string
@@ -5788,6 +5873,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5788
5873
  ```
5789
5874
 
5790
5875
  @method begin
5876
+ @static
5877
+ @for @ember/runloop
5791
5878
  @return {void}
5792
5879
  @public
5793
5880
  */
@@ -5807,6 +5894,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5807
5894
  ```
5808
5895
 
5809
5896
  @method end
5897
+ @static
5898
+ @for @ember/runloop
5810
5899
  @return {void}
5811
5900
  @public
5812
5901
  */
@@ -5854,6 +5943,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5854
5943
  ```
5855
5944
 
5856
5945
  @method schedule
5946
+ @static
5947
+ @for @ember/runloop
5857
5948
  @param {String} queue The name of the queue to schedule against.
5858
5949
  Default queues are 'sync' and 'actions'
5859
5950
  @param {Object} [target] target object to use as the context when invoking a method.
@@ -5894,6 +5985,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5894
5985
  ```
5895
5986
 
5896
5987
  @method sync
5988
+ @static
5989
+ @for @ember/runloop
5897
5990
  @return {void}
5898
5991
  @private
5899
5992
  */
@@ -5920,6 +6013,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5920
6013
  ```
5921
6014
 
5922
6015
  @method later
6016
+ @static
6017
+ @for @ember/runloop
5923
6018
  @param {Object} [target] target of method to invoke
5924
6019
  @param {Function|String} method The method to invoke.
5925
6020
  If you pass a string it will be resolved on the
@@ -5938,6 +6033,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
5938
6033
  to calling `scheduleOnce` with the "actions" queue.
5939
6034
 
5940
6035
  @method once
6036
+ @static
6037
+ @for @ember/runloop
5941
6038
  @param {Object} [target] The target of the method to invoke.
5942
6039
  @param {Function|String} method The method to invoke.
5943
6040
  If you pass a string it will be resolved on the
@@ -6014,6 +6111,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6014
6111
  Available queues, and their order, can be found at `run.queues`
6015
6112
 
6016
6113
  @method scheduleOnce
6114
+ @static
6115
+ @for @ember/runloop
6017
6116
  @param {String} [queue] The name of the queue to schedule against. Default queues are 'sync' and 'actions'.
6018
6117
  @param {Object} [target] The target of the method to invoke.
6019
6118
  @param {Function|String} method The method to invoke.
@@ -6086,6 +6185,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6086
6185
  outside of the current run loop, i.e. with `run.next`.
6087
6186
 
6088
6187
  @method next
6188
+ @static
6189
+ @for @ember/runloop
6089
6190
  @param {Object} [target] target of method to invoke
6090
6191
  @param {Function|String} method The method to invoke.
6091
6192
  If you pass a string it will be resolved on the
@@ -6154,6 +6255,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6154
6255
  ```
6155
6256
 
6156
6257
  @method cancel
6258
+ @static
6259
+ @for @ember/runloop
6157
6260
  @param {Object} timer Timer object to cancel
6158
6261
  @return {Boolean} true if canceled or false/undefined if it wasn't found
6159
6262
  @public
@@ -6220,6 +6323,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6220
6323
  ```
6221
6324
 
6222
6325
  @method debounce
6326
+ @static
6327
+ @for @ember/runloop
6223
6328
  @param {Object} [target] target of method to invoke
6224
6329
  @param {Function|String} method The method to invoke.
6225
6330
  May be a function or a string. If you pass a string
@@ -6263,6 +6368,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6263
6368
  ```
6264
6369
 
6265
6370
  @method throttle
6371
+ @static
6372
+ @for @ember/runloop
6266
6373
  @param {Object} [target] target of method to invoke
6267
6374
  @param {Function|String} method The method to invoke.
6268
6375
  May be a function or a string. If you pass a string
@@ -6294,6 +6401,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6294
6401
  }
6295
6402
  };
6296
6403
 
6404
+ /**
6405
+ @module ember
6406
+ */
6297
6407
  /**
6298
6408
  Helper class that allows you to register your library with Ember.
6299
6409
 
@@ -6367,7 +6477,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6367
6477
 
6368
6478
  /**
6369
6479
  @module ember
6370
- @submodule ember-metal
6371
6480
  */
6372
6481
 
6373
6482
  /*
@@ -6375,7 +6484,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6375
6484
  which are often used as dictionaries, may only have Strings as keys.
6376
6485
 
6377
6486
  Because Ember has a way to get a unique identifier for every object
6378
- via `Ember.guidFor`, we can implement a performant Map with arbitrary
6487
+ via `guidFor`, we can implement a performant Map with arbitrary
6379
6488
  keys. Because it is commonly used in low-level bookkeeping, Map is
6380
6489
  implemented as a pure JavaScript object for performance.
6381
6490
 
@@ -6385,7 +6494,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6385
6494
  forEach method for iteration.
6386
6495
 
6387
6496
  Map is mocked out to look like an Ember object, so you can do
6388
- `Ember.Map.create()` for symmetry with other Ember classes.
6497
+ `EmberMap.create()` for symmetry with other Ember classes.
6389
6498
  */
6390
6499
  function missingFunction(fn) {
6391
6500
  throw new TypeError(Object.prototype.toString.call(fn) + ' is not a function');
@@ -6593,7 +6702,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6593
6702
  Internally, a Map has two data structures:
6594
6703
 
6595
6704
  1. `keys`: an OrderedSet of all of the existing keys
6596
- 2. `values`: a JavaScript Object indexed by the `Ember.guidFor(key)`
6705
+ 2. `values`: a JavaScript Object indexed by the `guidFor(key)`
6597
6706
 
6598
6707
  When a key/value pair is added for the first time, we
6599
6708
  add the key to the `keys` OrderedSet, and create or
@@ -6798,7 +6907,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6798
6907
  @param [options]
6799
6908
  @param {*} [options.defaultValue]
6800
6909
  @return {Ember.MapWithDefault|Ember.Map} If options are passed, returns
6801
- `Ember.MapWithDefault` otherwise returns `Ember.Map`
6910
+ `MapWithDefault` otherwise returns `EmberMap`
6802
6911
  @private
6803
6912
  */
6804
6913
  MapWithDefault.create = function (options) {
@@ -6847,23 +6956,32 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6847
6956
  };
6848
6957
 
6849
6958
  /**
6850
- To get multiple properties at once, call `Ember.getProperties`
6959
+ @module @ember/object
6960
+ */
6961
+
6962
+ /**
6963
+ To get multiple properties at once, call `getProperties`
6851
6964
  with an object followed by a list of strings or an array:
6852
6965
 
6853
6966
  ```javascript
6854
- Ember.getProperties(record, 'firstName', 'lastName', 'zipCode');
6967
+ import { getProperties } from '@ember/object';
6968
+
6969
+ getProperties(record, 'firstName', 'lastName', 'zipCode');
6855
6970
  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
6856
6971
  ```
6857
6972
 
6858
6973
  is equivalent to:
6859
6974
 
6860
6975
  ```javascript
6861
- Ember.getProperties(record, ['firstName', 'lastName', 'zipCode']);
6976
+ import { getProperties } from '@ember/object';
6977
+
6978
+ getProperties(record, ['firstName', 'lastName', 'zipCode']);
6862
6979
  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
6863
6980
  ```
6864
6981
 
6865
6982
  @method getProperties
6866
- @for Ember
6983
+ @static
6984
+ @for @ember/object
6867
6985
  @param {Object} obj
6868
6986
  @param {String...|Array} list of keys to get
6869
6987
  @return {Object}
@@ -6884,6 +7002,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6884
7002
  return ret;
6885
7003
  }
6886
7004
 
7005
+ /**
7006
+ @module @ember/object
7007
+ */
6887
7008
  /**
6888
7009
  Set a list of properties on an object. These properties are set inside
6889
7010
  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
@@ -6900,6 +7021,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6900
7021
  ```
6901
7022
 
6902
7023
  @method setProperties
7024
+ @static
7025
+ @for @ember/object
6903
7026
  @param obj
6904
7027
  @param {Object} properties
6905
7028
  @return properties
@@ -6923,7 +7046,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6923
7046
  }
6924
7047
 
6925
7048
  /**
6926
- @module ember-metal
7049
+ @module @ember/object
6927
7050
  */
6928
7051
 
6929
7052
  var AFTER_OBSERVERS = ':change';
@@ -6939,7 +7062,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6939
7062
 
6940
7063
  /**
6941
7064
  @method addObserver
6942
- @for Ember
7065
+ @static
7066
+ @for @ember/object/observers
6943
7067
  @param obj
6944
7068
  @param {String} _path
6945
7069
  @param {Object|Function} target
@@ -6959,7 +7083,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6959
7083
 
6960
7084
  /**
6961
7085
  @method removeObserver
6962
- @for Ember
7086
+ @static
7087
+ @for @ember/object/observers
6963
7088
  @param obj
6964
7089
  @param {String} path
6965
7090
  @param {Object|Function} target
@@ -6975,7 +7100,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
6975
7100
 
6976
7101
  /**
6977
7102
  @method _addBeforeObserver
6978
- @for Ember
7103
+ @static
7104
+ @for @ember/object/observers
6979
7105
  @param obj
6980
7106
  @param {String} path
6981
7107
  @param {Object|Function} target
@@ -7005,7 +7131,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7005
7131
 
7006
7132
  /**
7007
7133
  @method removeBeforeObserver
7008
- @for Ember
7134
+ @static
7135
+ @for @ember/object/observers
7009
7136
  @param obj
7010
7137
  @param {String} path
7011
7138
  @param {Object|Function} target
@@ -7022,7 +7149,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7022
7149
 
7023
7150
  /**
7024
7151
  @module ember
7025
- @submodule ember-metal
7026
7152
  */
7027
7153
 
7028
7154
  // ..........................................................
@@ -7503,8 +7629,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7503
7629
  }
7504
7630
 
7505
7631
  /**
7506
- @module ember
7507
- @submodule ember-metal
7632
+ @module @ember/object
7508
7633
  */
7509
7634
  var a_concat = Array.prototype.concat;
7510
7635
  var isArray = Array.isArray;
@@ -7880,7 +8005,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7880
8005
 
7881
8006
  /**
7882
8007
  @method mixin
7883
- @for Ember
7884
8008
  @param obj
7885
8009
  @param mixins*
7886
8010
  @return obj
@@ -7896,21 +8020,28 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7896
8020
  }
7897
8021
 
7898
8022
  /**
7899
- The `Ember.Mixin` class allows you to create mixins, whose properties can be
8023
+ The `Mixin` class allows you to create mixins, whose properties can be
7900
8024
  added to other classes. For instance,
7901
8025
 
7902
8026
  ```javascript
7903
- const EditableMixin = Ember.Mixin.create({
8027
+ import Mixin from '@ember/object/mixin';
8028
+
8029
+ const EditableMixin = Mixin.create({
7904
8030
  edit() {
7905
8031
  console.log('starting to edit');
7906
8032
  this.set('isEditing', true);
7907
8033
  },
7908
8034
  isEditing: false
7909
8035
  });
8036
+ ```
8037
+
8038
+ ```javascript
8039
+ import EmberObject from '@ember/object';
8040
+ import EditableMixin from '../mixins/editable';
7910
8041
 
7911
8042
  // Mix mixins into classes by passing them as the first arguments to
7912
8043
  // `.extend.`
7913
- const Comment = Ember.Object.extend(EditableMixin, {
8044
+ const Comment = EmberObject.extend(EditableMixin, {
7914
8045
  post: null
7915
8046
  });
7916
8047
 
@@ -7921,8 +8052,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7921
8052
  comment.edit(); // outputs 'starting to edit'
7922
8053
  ```
7923
8054
 
7924
- Note that Mixins are created with `Ember.Mixin.create`, not
7925
- `Ember.Mixin.extend`.
8055
+ Note that Mixins are created with `Mixin.create`, not
8056
+ `Mixin.extend`.
7926
8057
 
7927
8058
  Note that mixins extend a constructor's prototype so arrays and object literals
7928
8059
  defined as properties will be shared amongst objects that implement the mixin.
@@ -7931,28 +8062,43 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7931
8062
 
7932
8063
  ```javascript
7933
8064
  // filters array will be shared amongst any object implementing mixin
7934
- const FilterableMixin = Ember.Mixin.create({
7935
- filters: Ember.A()
8065
+ import Mixin from '@ember/object/mixin';
8066
+ import { A } from '@ember/array';
8067
+
8068
+ const FilterableMixin = Mixin.create({
8069
+ filters: A()
7936
8070
  });
8071
+ ```
8072
+
8073
+ ```javascript
8074
+ import Mixin from '@ember/object/mixin';
8075
+ import { A } from '@ember/array';
8076
+ import { computed } from '@ember/object';
7937
8077
 
7938
8078
  // filters will be a separate array for every object implementing the mixin
7939
- const FilterableMixin = Ember.Mixin.create({
7940
- filters: Ember.computed(function() {
7941
- return Ember.A();
8079
+ const FilterableMixin = Mixin.create({
8080
+ filters: computed(function() {
8081
+ return A();
7942
8082
  })
7943
8083
  });
8084
+ ```
8085
+
8086
+ ```javascript
8087
+ import Mixin from '@ember/object/mixin';
8088
+ import { A } from '@ember/array';
7944
8089
 
7945
8090
  // filters will be created as a separate array during the object's initialization
7946
- const Filterable = Ember.Mixin.create({
8091
+ const Filterable = Mixin.create({
8092
+ filters: null,
8093
+
7947
8094
  init() {
7948
8095
  this._super(...arguments);
7949
- this.set("filters", Ember.A());
8096
+ this.set("filters", A());
7950
8097
  }
7951
8098
  });
7952
8099
  ```
7953
8100
 
7954
8101
  @class Mixin
7955
- @namespace Ember
7956
8102
  @public
7957
8103
  */
7958
8104
 
@@ -7997,6 +8143,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
7997
8143
 
7998
8144
  /**
7999
8145
  @method create
8146
+ @for @ember/object/mixin
8000
8147
  @static
8001
8148
  @param arguments*
8002
8149
  @public
@@ -8015,7 +8162,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8015
8162
  };
8016
8163
 
8017
8164
  // returns the mixins currently applied to the specified object
8018
- // TODO: Make Ember.mixin
8165
+ // TODO: Make `mixin`
8019
8166
 
8020
8167
 
8021
8168
  Mixin.mixins = function mixins(obj) {
@@ -8234,7 +8381,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8234
8381
  ```
8235
8382
 
8236
8383
  @method aliasMethod
8237
- @for Ember
8384
+ @static
8385
+ @for @ember/object
8238
8386
  @param {String} methodName name of the method to alias
8239
8387
  @public
8240
8388
  */
@@ -8250,8 +8398,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8250
8398
  Specify a method that observes property changes.
8251
8399
 
8252
8400
  ```javascript
8253
- Ember.Object.extend({
8254
- valueObserver: Ember.observer('value', function() {
8401
+ import EmberObject from '@ember/object';
8402
+ import { observer } from '@ember/object';
8403
+
8404
+ export default EmberObject.extend({
8405
+ valueObserver: observer('value', function() {
8255
8406
  // Executes whenever the "value" property changes
8256
8407
  })
8257
8408
  });
@@ -8261,11 +8412,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8261
8412
  enabled.
8262
8413
 
8263
8414
  @method observer
8264
- @for Ember
8415
+ @for @ember/object
8265
8416
  @param {String} propertyNames*
8266
8417
  @param {Function} func
8267
8418
  @return func
8268
8419
  @public
8420
+ @static
8269
8421
  */
8270
8422
  function observer() {
8271
8423
  var _paths = void 0,
@@ -8277,7 +8429,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8277
8429
 
8278
8430
  if (typeof args[args.length - 1] !== 'function') {
8279
8431
  // revert to old, soft-deprecated argument ordering
8280
- true && !false && emberDebug.deprecate('Passing the dependentKeys after the callback function in Ember.observer is deprecated. Ensure the callback function is the last argument.', false, { id: 'ember-metal.observer-argument-order', until: '3.0.0' });
8432
+ true && !false && emberDebug.deprecate('Passing the dependentKeys after the callback function in observer is deprecated. Ensure the callback function is the last argument.', false, { id: 'ember-metal.observer-argument-order', until: '3.0.0' });
8281
8433
 
8282
8434
  func = args.shift();
8283
8435
  _paths = args;
@@ -8286,10 +8438,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8286
8438
  _paths = args;
8287
8439
  }
8288
8440
 
8289
- true && !(typeof func === 'function') && emberDebug.assert('Ember.observer called without a function', typeof func === 'function');
8441
+ true && !(typeof func === 'function') && emberDebug.assert('observer called without a function', typeof func === 'function');
8290
8442
  true && !(_paths.length > 0 && _paths.every(function (p) {
8291
8443
  return typeof p === 'string' && p.length;
8292
- })) && emberDebug.assert('Ember.observer called without valid path', _paths.length > 0 && _paths.every(function (p) {
8444
+ })) && emberDebug.assert('observer called without valid path', _paths.length > 0 && _paths.every(function (p) {
8293
8445
  return typeof p === 'string' && p.length;
8294
8446
  }));
8295
8447
 
@@ -8310,15 +8462,17 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8310
8462
  Specify a method that observes property changes.
8311
8463
 
8312
8464
  ```javascript
8313
- Ember.Object.extend({
8465
+ import EmberObject from '@ember/object';
8466
+
8467
+ EmberObject.extend({
8314
8468
  valueObserver: Ember.immediateObserver('value', function() {
8315
8469
  // Executes whenever the "value" property changes
8316
8470
  })
8317
8471
  });
8318
8472
  ```
8319
8473
 
8320
- In the future, `Ember.observer` may become asynchronous. In this event,
8321
- `Ember.immediateObserver` will maintain the synchronous behavior.
8474
+ In the future, `observer` may become asynchronous. In this event,
8475
+ `immediateObserver` will maintain the synchronous behavior.
8322
8476
 
8323
8477
  Also available as `Function.prototype.observesImmediately` if prototype extensions are
8324
8478
  enabled.
@@ -8327,12 +8481,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8327
8481
  @for Ember
8328
8482
  @param {String} propertyNames*
8329
8483
  @param {Function} func
8330
- @deprecated Use `Ember.observer` instead.
8484
+ @deprecated Use `observer` instead.
8331
8485
  @return func
8332
8486
  @private
8333
8487
  */
8334
8488
  function _immediateObserver() {
8335
- true && !false && emberDebug.deprecate('Usage of `Ember.immediateObserver` is deprecated, use `Ember.observer` instead.', false, { id: 'ember-metal.immediate-observer', until: '3.0.0' });
8489
+ true && !false && emberDebug.deprecate('Usage of `Ember.immediateObserver` is deprecated, use `observer` instead.', false, { id: 'ember-metal.immediate-observer', until: '3.0.0' });
8336
8490
 
8337
8491
  for (var i = 0; i < arguments.length; i++) {
8338
8492
  var arg = arguments[i];
@@ -8393,6 +8547,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8393
8547
  return func;
8394
8548
  }
8395
8549
 
8550
+ /**
8551
+ @module ember
8552
+ @private
8553
+ */
8554
+
8396
8555
  /**
8397
8556
  Read-only property that returns the result of a container lookup.
8398
8557
 
@@ -8416,7 +8575,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8416
8575
  var desc = this[keyName];
8417
8576
  var owner = emberUtils.getOwner(this) || this.container; // fallback to `container` for backwards compat
8418
8577
 
8419
- true && !(desc && desc.isDescriptor && desc.type) && emberDebug.assert('InjectedProperties should be defined with the Ember.inject computed property macros.', desc && desc.isDescriptor && desc.type);
8578
+ true && !(desc && desc.isDescriptor && desc.type) && emberDebug.assert('InjectedProperties should be defined with the inject computed property macros.', desc && desc.isDescriptor && desc.type);
8420
8579
  true && !owner && emberDebug.assert('Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.', owner);
8421
8580
 
8422
8581
  return owner.lookup(desc.type + ':' + (desc.name || keyName));
@@ -8506,11 +8665,6 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
8506
8665
  return Descriptor$$1;
8507
8666
  }(Descriptor);
8508
8667
 
8509
- /**
8510
- @module ember
8511
- @submodule ember-metal
8512
- */
8513
-
8514
8668
  exports['default'] = Ember;
8515
8669
  exports.computed = computed;
8516
8670
  exports.cacheFor = cacheFor;