ember-source 4.9.0-alpha.3 → 4.9.0-alpha.4

package/dist/packages/@ember/array/proxy.js

@@ -92,17 +92,6 @@ class ArrayProxy extends EmberObject {
   willDestroy() {
     this._removeArrangedContentArrayObserver();
   }
-  /**
-    Should actually retrieve the object at the specified index from the
-    content. You can override this method in subclasses to transform the
-    content item to something new.
-       This method will only be called if content is non-`null`.
-       @method objectAtContent
-    @param {Number} idx The index to retrieve.
-    @return {Object} the value or undefined if none found
-    @public
-  */
-
 
   objectAtContent(idx) {
     let arrangedContent = get(this, 'arrangedContent');
@@ -116,19 +105,6 @@ class ArrayProxy extends EmberObject {
     assert('Mutating an arranged ArrayProxy is not allowed', get(this, 'arrangedContent') === get(this, 'content'));
     this.replaceContent(idx, amt, objects);
   }
-  /**
-    Should actually replace the specified objects on the content array.
-    You can override this method in subclasses to transform the content item
-    into something new.
-       This method will only be called if content is non-`null`.
-       @method replaceContent
-    @param {Number} idx The starting index
-    @param {Number} amt The number of items to remove from the content.
-    @param {Array} objects Optional array of objects to insert.
-    @return {void}
-    @public
-  */
-
 
   replaceContent(idx, amt, objects) {
     let content = get(this, 'content');
@@ -295,13 +271,6 @@ class ArrayProxy extends EmberObject {
 }
 
 ArrayProxy.reopen(MutableArray, {
-  /**
-    The array that the proxy pretends to be. In the default `ArrayProxy`
-    implementation, this and `content` are the same. Subclasses of `ArrayProxy`
-    can override this property to provide things like sorting and filtering.
-       @property arrangedContent
-    @public
-  */
   arrangedContent: alias('content')
 });
 export default ArrayProxy;

package/dist/packages/@ember/controller/index.js

@@ -12,20 +12,6 @@ const ControllerMixin = Mixin.create(ActionHandler, {
   /* ducktype as a controller */
   isController: true,
   concatenatedProperties: ['queryParams'],
-
-  /**
-    The object to which actions from the view should be sent.
-       For example, when a Handlebars template uses the `{{action}}` helper,
-    it will attempt to send the action to the view's controller's `target`.
-       By default, the value of the target property is set to the router, and
-    is injected when a controller is instantiated. This injection is applied
-    as part of the application's initialization process. In most cases the
-    `target` property will automatically be set to the logical consumer of
-    actions for the controller.
-       @property target
-    @default null
-    @public
-  */
   target: null,
   store: null,
 
@@ -40,12 +26,6 @@ const ControllerMixin = Mixin.create(ActionHandler, {
     }
   },
 
-  /**
-    The controller's current model. When retrieving or modifying a controller's
-    model, this property should be used instead of the `content` property.
-       @property model
-    @public
-  */
   model: computed({
     get() {
       return this[MODEL];
@@ -56,30 +36,6 @@ const ControllerMixin = Mixin.create(ActionHandler, {
     }
 
   }),
-
-  /**
-    Defines which query parameters the controller accepts.
-    If you give the names `['category','page']` it will bind
-    the values of these query parameters to the variables
-    `this.category` and `this.page`.
-       By default, query parameters are parsed as strings. This
-    may cause unexpected behavior if a query parameter is used with `toggleProperty`,
-    because the initial value set for `param=false` will be the string `"false"`, which is truthy.
-       To avoid this, you may specify that the query parameter should be parsed as a boolean
-    by using the following verbose form with a `type` property:
-    ```javascript
-      queryParams: [{
-        category: {
-          type: 'boolean'
-        }
-      }]
-    ```
-    Available values for the `type` parameter are `'boolean'`, `'number'`, `'array'`, and `'string'`.
-    If query param type is not specified, it will default to `'string'`.
-       @for Ember.ControllerMixin
-    @property queryParams
-    @public
-  */
   queryParams: null,
 
   /**
@@ -119,67 +75,6 @@ const ControllerMixin = Mixin.create(ActionHandler, {
     delegate(prop, value);
   },
 
-  /**
-    Transition the application into another route. The route may
-    be either a single route or route path:
-       ```javascript
-    aController.transitionToRoute('blogPosts');
-    aController.transitionToRoute('blogPosts.recentEntries');
-    ```
-       Optionally supply a model for the route in question. The model
-    will be serialized into the URL using the `serialize` hook of
-    the route:
-       ```javascript
-    aController.transitionToRoute('blogPost', aPost);
-    ```
-       If a literal is passed (such as a number or a string), it will
-    be treated as an identifier instead. In this case, the `model`
-    hook of the route will be triggered:
-       ```javascript
-    aController.transitionToRoute('blogPost', 1);
-    ```
-       Multiple models will be applied last to first recursively up the
-    route tree.
-       ```app/router.js
-    Router.map(function() {
-      this.route('blogPost', { path: ':blogPostId' }, function() {
-        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-      });
-    });
-    ```
-       ```javascript
-    aController.transitionToRoute('blogComment', aPost, aComment);
-    aController.transitionToRoute('blogComment', 1, 13);
-    ```
-       It is also possible to pass a URL (a string that starts with a
-    `/`).
-       ```javascript
-    aController.transitionToRoute('/');
-    aController.transitionToRoute('/blog/post/1/comment/13');
-    aController.transitionToRoute('/blog/posts?sort=title');
-    ```
-       An options hash with a `queryParams` property may be provided as
-    the final argument to add query parameters to the destination URL.
-       ```javascript
-    aController.transitionToRoute('blogPost', 1, {
-      queryParams: { showComments: 'true' }
-    });
-       // if you just want to transition the query parameters without changing the route
-    aController.transitionToRoute({ queryParams: { sort: 'date' } });
-    ```
-       See also [replaceRoute](/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
-       @for Ember.ControllerMixin
-    @method transitionToRoute
-    @deprecated Use transitionTo from the Router service instead.
-    @param {String} [name] the name of the route or a URL
-    @param {...Object} models the model(s) or identifier(s) to be used
-      while transitioning to the route.
-    @param {Object} [options] optional hash with a queryParams property
-      containing a mapping of query parameters
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @public
-  */
   transitionToRoute(...args) {
     var _a;
 
@@ -193,57 +88,6 @@ const ControllerMixin = Mixin.create(ActionHandler, {
     return method.apply(target, prefixRouteNameArg(this, args));
   },
 
-  /**
-    Transition into another route while replacing the current URL, if possible.
-    This will replace the current history entry instead of adding a new one.
-    Beside that, it is identical to `transitionToRoute` in all other respects.
-       ```javascript
-    aController.replaceRoute('blogPosts');
-    aController.replaceRoute('blogPosts.recentEntries');
-    ```
-       Optionally supply a model for the route in question. The model
-    will be serialized into the URL using the `serialize` hook of
-    the route:
-       ```javascript
-    aController.replaceRoute('blogPost', aPost);
-    ```
-       If a literal is passed (such as a number or a string), it will
-    be treated as an identifier instead. In this case, the `model`
-    hook of the route will be triggered:
-       ```javascript
-    aController.replaceRoute('blogPost', 1);
-    ```
-       Multiple models will be applied last to first recursively up the
-    route tree.
-       ```app/router.js
-    Router.map(function() {
-      this.route('blogPost', { path: ':blogPostId' }, function() {
-        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-      });
-    });
-    ```
-       ```
-    aController.replaceRoute('blogComment', aPost, aComment);
-    aController.replaceRoute('blogComment', 1, 13);
-    ```
-       It is also possible to pass a URL (a string that starts with a
-    `/`).
-       ```javascript
-    aController.replaceRoute('/');
-    aController.replaceRoute('/blog/post/1/comment/13');
-    ```
-       @for Ember.ControllerMixin
-    @method replaceRoute
-    @deprecated Use replaceWith from the Router service instead.
-    @param {String} [name] the name of the route or a URL
-    @param {...Object} models the model(s) or identifier(s) to be used
-    while transitioning to the route.
-    @param {Object} [options] optional hash with a queryParams property
-    containing a mapping of query parameters
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @public
-  */
   replaceRoute(...args) {
     var _a;
 

package/dist/packages/@ember/debug/data-adapter.js

@@ -1,11 +1,12 @@
 import { getOwner } from '@ember/-internals/owner';
-import { _backburner } from '@ember/runloop';
+import { _backburner, next } from '@ember/runloop';
 import { get } from '@ember/object';
 import { dasherize } from '@ember/string';
 import Namespace from '@ember/application/namespace';
 import EmberObject from '@ember/object';
 import { A as emberA } from '@ember/array';
 import { consumeTag, createCache, getValue, tagFor, untrack } from '@glimmer/validator';
+import { assert } from '.';
 
 function iterate(arr, fn) {
   if (Symbol.iterator in arr) {
@@ -13,6 +14,11 @@ function iterate(arr, fn) {
       fn(item);
     }
   } else {
+    // SAFETY: this cast required to work this way to interop between TS 4.8
+    // and 4.9. When we drop support for 4.8, it will narrow correctly via the
+    // use of the `in` operator above. (Preferably we will solve this by just
+    // switching to require `Symbol.iterator` instead.)
+    assert('', typeof arr.forEach === 'function');
     arr.forEach(fn);
   }
 }
@@ -98,7 +104,7 @@ class TypeWatcher {
       consumeTag(tagFor(records, '[]'));
 
       if (hasBeenAccessed === true) {
-        onChange();
+        next(onChange);
       } else {
         hasBeenAccessed = true;
       }

package/dist/packages/@ember/object/observable.js

@@ -7,113 +7,18 @@ import { get, set, getProperties, setProperties } from '@ember/object';
 import Mixin from '@ember/object/mixin';
 import { assert } from '@ember/debug';
 const Observable = Mixin.create({
-  /**
-    Retrieves the value of a property from the object.
-       This method is usually similar to using `object[keyName]` or `object.keyName`,
-    however it supports both computed properties and the unknownProperty
-    handler.
-       Because `get` unifies the syntax for accessing all these kinds
-    of properties, it can make many refactorings easier, such as replacing a
-    simple property with a computed property, or vice versa.
-       ### Computed Properties
-       Computed properties are methods defined with the `property` modifier
-    declared at the end, such as:
-       ```javascript
-    import { computed } from '@ember/object';
-       fullName: computed('firstName', 'lastName', function() {
-      return this.get('firstName') + ' ' + this.get('lastName');
-    })
-    ```
-       When you call `get` on a computed property, the function will be
-    called and the return value will be returned instead of the function
-    itself.
-       ### Unknown Properties
-       Likewise, if you try to call `get` on a property whose value is
-    `undefined`, the `unknownProperty()` method will be called on the object.
-    If this method returns any value other than `undefined`, it will be returned
-    instead. This allows you to implement "virtual" properties that are
-    not defined upfront.
-       @method get
-    @param {String} keyName The property to retrieve
-    @return {Object} The property value or undefined.
-    @public
-  */
   get(keyName) {
     return get(this, keyName);
   },
 
-  /**
-    To get the values of multiple properties at once, call `getProperties`
-    with a list of strings or an array:
-       ```javascript
-    record.getProperties('firstName', 'lastName', 'zipCode');
-    // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-    ```
-       is equivalent to:
-       ```javascript
-    record.getProperties(['firstName', 'lastName', 'zipCode']);
-    // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-    ```
-       @method getProperties
-    @param {String...|Array} list of keys to get
-    @return {Object}
-    @public
-  */
   getProperties(...args) {
     return getProperties(this, ...args);
   },
 
-  /**
-    Sets the provided key or path to the value.
-       ```javascript
-    record.set("key", value);
-    ```
-       This method is generally very similar to calling `object["key"] = value` or
-    `object.key = value`, except that it provides support for computed
-    properties, the `setUnknownProperty()` method and property observers.
-       ### Computed Properties
-       If you try to set a value on a key that has a computed property handler
-    defined (see the `get()` method for an example), then `set()` will call
-    that method, passing both the value and key instead of simply changing
-    the value itself. This is useful for those times when you need to
-    implement a property that is composed of one or more member
-    properties.
-       ### Unknown Properties
-       If you try to set a value on a key that is undefined in the target
-    object, then the `setUnknownProperty()` handler will be called instead. This
-    gives you an opportunity to implement complex "virtual" properties that
-    are not predefined on the object. If `setUnknownProperty()` returns
-    undefined, then `set()` will simply set the value on the object.
-       ### Property Observers
-       In addition to changing the property, `set()` will also register a property
-    change with the object. Unless you have placed this call inside of a
-    `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers
-    (i.e. observer methods declared on the same object), will be called
-    immediately. Any "remote" observers (i.e. observer methods declared on
-    another object) will be placed in a queue and called at a later time in a
-    coalesced manner.
-       @method set
-    @param {String} keyName The property to set
-    @param {Object} value The value to set or `null`.
-    @return {Object} The passed value
-    @public
-  */
   set(keyName, value) {
     return set(this, keyName, value);
   },
 
-  /**
-    Sets a list of properties at once. These properties are set inside
-    a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-    observers will be buffered.
-       ```javascript
-    record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
-    ```
-       @method setProperties
-    @param {Object} hash the hash of keys and values to set
-    @return {Object} The passed in hash
-    @public
-  */
   setProperties(hash) {
     return setProperties(this, hash);
   },
@@ -153,104 +58,16 @@ const Observable = Mixin.create({
     return this;
   },
 
-  /**
-    Notify the observer system that a property has just changed.
-       Sometimes you need to change a value directly or indirectly without
-    actually calling `get()` or `set()` on it. In this case, you can use this
-    method instead. Calling this method will notify all observers that the
-    property has potentially changed value.
-       @method notifyPropertyChange
-    @param {String} keyName The property key to be notified about.
-    @return {Observable}
-    @public
-  */
   notifyPropertyChange(keyName) {
     notifyPropertyChange(this, keyName);
     return this;
   },
 
-  /**
-    Adds an observer on a property.
-       This is the core method used to register an observer for a property.
-       Once you call this method, any time the key's value is set, your observer
-    will be notified. Note that the observers are triggered any time the
-    value is set, regardless of whether it has actually changed. Your
-    observer should be prepared to handle that.
-       There are two common invocation patterns for `.addObserver()`:
-       - Passing two arguments:
-      - the name of the property to observe (as a string)
-      - the function to invoke (an actual function)
-    - Passing three arguments:
-      - the name of the property to observe (as a string)
-      - the target object (will be used to look up and invoke a
-        function on)
-      - the name of the function to invoke on the target object
-        (as a string).
-       ```app/components/my-component.js
-    import Component from '@ember/component';
-       export default Component.extend({
-      init() {
-        this._super(...arguments);
-           // the following are equivalent:
-           // using three arguments
-        this.addObserver('foo', this, 'fooDidChange');
-           // using two arguments
-        this.addObserver('foo', (...args) => {
-          this.fooDidChange(...args);
-        });
-      },
-         fooDidChange() {
-        // your custom logic code
-      }
-    });
-    ```
-       ### Observer Methods
-       Observer methods have the following signature:
-       ```app/components/my-component.js
-    import Component from '@ember/component';
-       export default Component.extend({
-      init() {
-        this._super(...arguments);
-        this.addObserver('foo', this, 'fooDidChange');
-      },
-         fooDidChange(sender, key, value, rev) {
-        // your code
-      }
-    });
-    ```
-       The `sender` is the object that changed. The `key` is the property that
-    changes. The `value` property is currently reserved and unused. The `rev`
-    is the last property revision of the object when it changed, which you can
-    use to detect if the key value has really changed or not.
-       Usually you will not need the value or revision parameters at
-    the end. In this case, it is common to write observer methods that take
-    only a sender and key value as parameters or, if you aren't interested in
-    any of these values, to write an observer that has no parameters at all.
-       @method addObserver
-    @param {String} key The key to observe
-    @param {Object} target The target object to invoke
-    @param {String|Function} method The method to invoke
-    @param {Boolean} sync Whether the observer is sync or not
-    @return {Observable}
-    @public
-  */
   addObserver(key, target, method, sync) {
     addObserver(this, key, target, method, sync);
     return this;
   },
 
-  /**
-    Remove an observer you have previously registered on this object. Pass
-    the same key, target, and method you passed to `addObserver()` and your
-    target will no longer receive notifications.
-       @method removeObserver
-    @param {String} key The key to observe
-    @param {Object} target The target object to invoke
-    @param {String|Function} method The method to invoke
-    @param {Boolean} sync Whether the observer is async or not
-    @return {Observable}
-    @public
-  */
   removeObserver(key, target, method, sync) {
     removeObserver(this, key, target, method, sync);
     return this;
@@ -270,65 +87,20 @@ const Observable = Mixin.create({
     return hasListeners(this, `${key}:change`);
   },
 
-  /**
-    Set the value of a property to the current value plus some amount.
-       ```javascript
-    person.incrementProperty('age');
-    team.incrementProperty('score', 2);
-    ```
-       @method incrementProperty
-    @param {String} keyName The name of the property to increment
-    @param {Number} increment The amount to increment by. Defaults to 1
-    @return {Number} The new property value
-    @public
-  */
   incrementProperty(keyName, increment = 1) {
     assert('Must pass a numeric value to incrementProperty', !isNaN(parseFloat(String(increment))) && isFinite(increment));
     return set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
   },
 
-  /**
-    Set the value of a property to the current value minus some amount.
-       ```javascript
-    player.decrementProperty('lives');
-    orc.decrementProperty('health', 5);
-    ```
-       @method decrementProperty
-    @param {String} keyName The name of the property to decrement
-    @param {Number} decrement The amount to decrement by. Defaults to 1
-    @return {Number} The new property value
-    @public
-  */
   decrementProperty(keyName, decrement = 1) {
     assert('Must pass a numeric value to decrementProperty', (typeof decrement === 'number' || !isNaN(parseFloat(decrement))) && isFinite(decrement));
     return set(this, keyName, (get(this, keyName) || 0) - decrement);
   },
 
-  /**
-    Set the value of a boolean property to the opposite of its
-    current value.
-       ```javascript
-    starship.toggleProperty('warpDriveEngaged');
-    ```
-       @method toggleProperty
-    @param {String} keyName The name of the property to toggle
-    @return {Boolean} The new property value
-    @public
-  */
   toggleProperty(keyName) {
     return set(this, keyName, !get(this, keyName));
   },
 
-  /**
-    Returns the cached value of a computed property, if it exists.
-    This allows you to inspect the value of a computed property
-    without accidentally invoking it if it is intended to be
-    generated lazily.
-       @method cacheFor
-    @param {String} keyName
-    @return {Object} The cached value of the computed property, if any
-    @public
-  */
   cacheFor(keyName) {
     let meta = peekMeta(this);
 

package/dist/packages/@ember/object/promise-proxy-mixin.js

@@ -32,66 +32,15 @@ function tap(proxy, promise) {
 }
 
 const PromiseProxyMixin = Mixin.create({
-  /**
-    If the proxied promise is rejected this will contain the reason
-    provided.
-       @property reason
-    @default null
-    @public
-  */
   reason: null,
-
-  /**
-    Once the proxied promise has settled this will become `false`.
-       @property isPending
-    @default true
-    @public
-  */
   isPending: computed('isSettled', function () {
     return !get(this, 'isSettled');
   }).readOnly(),
-
-  /**
-    Once the proxied promise has settled this will become `true`.
-       @property isSettled
-    @default false
-    @public
-  */
   isSettled: computed('isRejected', 'isFulfilled', function () {
     return get(this, 'isRejected') || get(this, 'isFulfilled');
   }).readOnly(),
-
-  /**
-    Will become `true` if the proxied promise is rejected.
-       @property isRejected
-    @default false
-    @public
-  */
   isRejected: false,
-
-  /**
-    Will become `true` if the proxied promise is fulfilled.
-       @property isFulfilled
-    @default false
-    @public
-  */
   isFulfilled: false,
-
-  /**
-    The promise whose fulfillment value is being proxied by this object.
-       This property must be specified upon creation, and should not be
-    changed once created.
-       Example:
-       ```javascript
-    import ObjectProxy from '@ember/object/proxy';
-    import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-       ObjectProxy.extend(PromiseProxyMixin).create({
-      promise: <thenable>
-    });
-    ```
-       @property promise
-    @public
-  */
   promise: computed({
     get() {
       throw new EmberError("PromiseProxy's promise must be set");
@@ -102,37 +51,8 @@ const PromiseProxyMixin = Mixin.create({
     }
 
   }),
-
-  /**
-    An alias to the proxied promise's `then`.
-       See RSVP.Promise.then.
-       @method then
-    @param {Function} callback
-    @return {RSVP.Promise}
-    @public
-  */
   then: promiseAlias('then'),
-
-  /**
-    An alias to the proxied promise's `catch`.
-       See RSVP.Promise.catch.
-       @method catch
-    @param {Function} callback
-    @return {RSVP.Promise}
-    @since 1.3.0
-    @public
-  */
   catch: promiseAlias('catch'),
-
-  /**
-    An alias to the proxied promise's `finally`.
-       See RSVP.Promise.finally.
-       @method finally
-    @param {Function} callback
-    @return {RSVP.Promise}
-    @since 1.3.0
-    @public
-  */
   finally: promiseAlias('finally')
 });
 

package/dist/packages/@ember/routing/route.js

@@ -93,7 +93,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       let [name] = params;
       assert('has name', name);
 
-      if (name in model) {
+      if (typeof model === 'object' && name in model) {
         object[name] = get(model, name);
       } else if (/_id$/.test(name)) {
         object[name] = get(model, 'id');

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.9.0-alpha.3";
+export default "4.9.0-alpha.4";