ember-source 4.5.0-alpha.4 → 4.5.0-beta.2

package/dist/packages/@ember/-internals/runtime/lib/mixins/action_handler.js

@@ -3,34 +3,22 @@
 */
 import { Mixin, get } from '@ember/-internals/metal';
 import { assert } from '@ember/debug';
-/**
-  `Ember.ActionHandler` is available on some familiar classes including
-  `Route`, `Component`, and `Controller`.
-  (Internally the mixin is used by `Ember.CoreView`, `Ember.ControllerMixin`,
-  and `Route` and available to the above classes through
-  inheritance.)
-
-  @class ActionHandler
-  @namespace Ember
-  @private
-*/
-
 const ActionHandler = Mixin.create({
   mergedProperties: ['actions'],
 
   /**
     The collection of functions, keyed by name, available on this
     `ActionHandler` as action targets.
-     These functions will be invoked when a matching `{{action}}` is triggered
+       These functions will be invoked when a matching `{{action}}` is triggered
     from within a template and the application's current route is this route.
-     Actions can also be invoked from other parts of your application
+       Actions can also be invoked from other parts of your application
     via `ActionHandler#send`.
-     The `actions` hash will inherit action handlers from
+       The `actions` hash will inherit action handlers from
     the `actions` hash defined on extended parent classes
     or mixins rather than just replace the entire hash, e.g.:
-     ```app/mixins/can-display-banner.js
+       ```app/mixins/can-display-banner.js
     import Mixin from '@ember/mixin';
-     export default Mixin.create({
+       export default Mixin.create({
       actions: {
         displayBanner(msg) {
           // ...
@@ -38,28 +26,28 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-     ```app/routes/welcome.js
+       ```app/routes/welcome.js
     import Route from '@ember/routing/route';
     import CanDisplayBanner from '../mixins/can-display-banner';
-     export default Route.extend(CanDisplayBanner, {
+       export default Route.extend(CanDisplayBanner, {
       actions: {
         playMusic() {
           // ...
         }
       }
     });
-     // `WelcomeRoute`, when active, will be able to respond
+       // `WelcomeRoute`, when active, will be able to respond
     // to both actions, since the actions hash is merged rather
     // then replaced when extending mixins / parent classes.
     this.send('displayBanner');
     this.send('playMusic');
     ```
-     Within a Controller, Route or Component's action handler,
+       Within a Controller, Route or Component's action handler,
     the value of the `this` context is the Controller, Route or
     Component object:
-     ```app/routes/song.js
+       ```app/routes/song.js
     import Route from '@ember/routing/route';
-     export default Route.extend({
+       export default Route.extend({
       actions: {
         myAction() {
           this.controllerFor("song");
@@ -69,13 +57,13 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-     It is also possible to call `this._super(...arguments)` from within an
+       It is also possible to call `this._super(...arguments)` from within an
     action handler if it overrides a handler defined on a parent
     class or mixin:
-     Take for example the following routes:
-     ```app/mixins/debug-route.js
+       Take for example the following routes:
+       ```app/mixins/debug-route.js
     import Mixin from '@ember/mixin';
-     export default Mixin.create({
+       export default Mixin.create({
       actions: {
         debugRouteInformation() {
           console.debug("It's a-me, console.debug!");
@@ -83,54 +71,54 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-     ```app/routes/annoying-debug.js
+       ```app/routes/annoying-debug.js
     import Route from '@ember/routing/route';
     import DebugRoute from '../mixins/debug-route';
-     export default Route.extend(DebugRoute, {
+       export default Route.extend(DebugRoute, {
       actions: {
         debugRouteInformation() {
           // also call the debugRouteInformation of mixed in DebugRoute
           this._super(...arguments);
-           // show additional annoyance
+             // show additional annoyance
           window.alert(...);
         }
       }
     });
     ```
-     ## Bubbling
-     By default, an action will stop bubbling once a handler defined
+       ## Bubbling
+       By default, an action will stop bubbling once a handler defined
     on the `actions` hash handles it. To continue bubbling the action,
     you must return `true` from the handler:
-     ```app/router.js
+       ```app/router.js
     Router.map(function() {
       this.route("album", function() {
         this.route("song");
       });
     });
     ```
-     ```app/routes/album.js
+       ```app/routes/album.js
     import Route from '@ember/routing/route';
-     export default Route.extend({
+       export default Route.extend({
       actions: {
         startPlaying: function() {
         }
       }
     });
     ```
-     ```app/routes/album-song.js
+       ```app/routes/album-song.js
     import Route from '@ember/routing/route';
-     export default Route.extend({
+       export default Route.extend({
       actions: {
         startPlaying() {
           // ...
-           if (actionShouldAlsoBeTriggeredOnParentRoute) {
+             if (actionShouldAlsoBeTriggeredOnParentRoute) {
             return true;
           }
         }
       }
     });
     ```
-     @property actions
+       @property actions
     @type Object
     @default null
     @public
@@ -140,14 +128,14 @@ const ActionHandler = Mixin.create({
     Triggers a named action on the `ActionHandler`. Any parameters
     supplied after the `actionName` string will be passed as arguments
     to the action target function.
-     If the `ActionHandler` has its `target` property set, actions may
+       If the `ActionHandler` has its `target` property set, actions may
     bubble to the `target`. Bubbling happens when an `actionName` can
     not be found in the `ActionHandler`'s `actions` hash or if the
     action target function returns `true`.
-     Example
-     ```app/routes/welcome.js
+       Example
+       ```app/routes/welcome.js
     import Route from '@ember/routing/route';
-     export default Route.extend({
+       export default Route.extend({
       actions: {
         playTheme() {
           this.send('playMusic', 'theme.mp3');
@@ -158,7 +146,7 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-     @method send
+       @method send
     @param {String} actionName The action to trigger
     @param {*} context a context to send with the action
     @public

package/dist/packages/@ember/-internals/runtime/lib/mixins/array.js

@@ -1176,7 +1176,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
       idx >= length, then append to the end of the array.
     @param {Number} amt Number of elements that should be removed from
       the array, starting at *idx*.
-    @param {EmberArray} objects An array of zero or more objects that should be
+    @param {EmberArray} [objects] An optional array of zero or more objects that should be
       inserted into the array at *idx*
     @public
   */

package/dist/packages/@ember/-internals/runtime/lib/mixins/comparable.js

@@ -1,34 +1,19 @@
 import { Mixin } from '@ember/-internals/metal';
-/**
-@module ember
-*/
-
-/**
-  Implements some standard methods for comparing objects. Add this mixin to
-  any class you create that can compare its instances.
-
-  You should implement the `compare()` method.
-
-  @class Comparable
-  @namespace Ember
-  @since Ember 0.9
-  @private
-*/
-
-export default Mixin.create({
+const Comparable = Mixin.create({
   /**
     __Required.__ You must implement this method to apply this mixin.
-     Override to return the result of the comparison of the two parameters. The
+       Override to return the result of the comparison of the two parameters. The
     compare method should return:
-     - `-1` if `a < b`
+       - `-1` if `a < b`
     - `0` if `a == b`
     - `1` if `a > b`
-     Default implementation raises an exception.
-     @method compare
+       Default implementation raises an exception.
+       @method compare
     @param a {Object} the first object to compare
     @param b {Object} the second object to compare
     @return {Number} the result of the comparison
     @private
   */
   compare: null
-});
+});
+export default Comparable;

package/dist/packages/@ember/-internals/runtime/lib/mixins/container_proxy.js

@@ -1,21 +1,9 @@
 import { schedule, join } from '@ember/runloop';
-/**
-@module ember
-*/
-
 import { Mixin } from '@ember/-internals/metal';
-/**
-  ContainerProxyMixin is used to provide public access to specific
-  container functionality.
-
-  @class ContainerProxyMixin
-  @private
-*/
-
-let containerProxyMixin = {
+const ContainerProxyMixin = Mixin.create({
   /**
    The container stores state.
-    @private
+      @private
    @property {Ember.Container} __container__
    */
   __container__: null,
@@ -23,16 +11,16 @@ let containerProxyMixin = {
   /**
    Returns an object that can be used to provide an owner to a
    manually created instance.
-    Example:
-    ```
+      Example:
+      ```
    import { getOwner } from '@ember/application';
-    let owner = getOwner(this);
-    User.create(
+      let owner = getOwner(this);
+      User.create(
      owner.ownerInjection(),
      { username: 'rwjblue' }
    )
    ```
-    @public
+      @public
    @method ownerInjection
    @since 2.3.0
    @return {Object}
@@ -43,30 +31,30 @@ let containerProxyMixin = {
 
   /**
    Given a fullName return a corresponding instance.
-    The default behavior is for lookup to return a singleton instance.
+      The default behavior is for lookup to return a singleton instance.
    The singleton is scoped to the container, allowing multiple containers
    to all have their own locally scoped singletons.
-    ```javascript
+      ```javascript
    let registry = new Registry();
    let container = registry.container();
-    registry.register('api:twitter', Twitter);
-    let twitter = container.lookup('api:twitter');
-    twitter instanceof Twitter; // => true
-    // by default the container will return singletons
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter');
+      twitter instanceof Twitter; // => true
+      // by default the container will return singletons
    let twitter2 = container.lookup('api:twitter');
    twitter2 instanceof Twitter; // => true
-    twitter === twitter2; //=> true
+      twitter === twitter2; //=> true
    ```
-    If singletons are not wanted an optional flag can be provided at lookup.
-    ```javascript
+      If singletons are not wanted an optional flag can be provided at lookup.
+      ```javascript
    let registry = new Registry();
    let container = registry.container();
-    registry.register('api:twitter', Twitter);
-    let twitter = container.lookup('api:twitter', { singleton: false });
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter', { singleton: false });
    let twitter2 = container.lookup('api:twitter', { singleton: false });
-    twitter === twitter2; //=> false
+      twitter === twitter2; //=> false
    ```
-    @public
+      @public
    @method lookup
    @param {String} fullName
    @param {Object} options
@@ -91,40 +79,40 @@ let containerProxyMixin = {
 
   /**
   Given a fullName return a factory manager.
-   This method returns a manager which can be used for introspection of the
+     This method returns a manager which can be used for introspection of the
   factory's class or for the creation of factory instances with initial
   properties. The manager is an object with the following properties:
-   * `class` - The registered or resolved class.
+     * `class` - The registered or resolved class.
   * `create` - A function that will create an instance of the class with
     any dependencies injected.
-   For example:
-   ```javascript
+     For example:
+     ```javascript
   import { getOwner } from '@ember/application';
-   let owner = getOwner(otherInstance);
+     let owner = getOwner(otherInstance);
   // the owner is commonly the `applicationInstance`, and can be accessed via
   // an instance initializer.
-   let factory = owner.factoryFor('service:bespoke');
-   factory.class;
+     let factory = owner.factoryFor('service:bespoke');
+     factory.class;
   // The registered or resolved class. For example when used with an Ember-CLI
   // app, this would be the default export from `app/services/bespoke.js`.
-   let instance = factory.create({
+     let instance = factory.create({
     someProperty: 'an initial property value'
   });
   // Create an instance with any injections and the passed options as
   // initial properties.
   ```
-   Any instances created via the factory's `.create()` method *must* be destroyed
+     Any instances created via the factory's `.create()` method *must* be destroyed
   manually by the caller of `.create()`. Typically, this is done during the creating
   objects own `destroy` or `willDestroy` methods.
-   @public
+     @public
   @method factoryFor
   @param {String} fullName
   @param {Object} options
   @return {FactoryManager}
   */
-  factoryFor(fullName, options = {}) {
-    return this.__container__.factoryFor(fullName, options);
+  factoryFor(fullName) {
+    return this.__container__.factoryFor(fullName);
   }
 
-};
-export default Mixin.create(containerProxyMixin);
+});
+export default ContainerProxyMixin;

package/dist/packages/@ember/-internals/runtime/lib/mixins/enumerable.js

@@ -1,16 +1,3 @@
 import { Mixin } from '@ember/-internals/metal';
-/**
-@module @ember/enumerable
-@private
-*/
-
-/**
-  The methods in this mixin have been moved to [MutableArray](/ember/release/classes/MutableArray). This mixin has
-  been intentionally preserved to avoid breaking Enumerable.detect checks
-  until the community migrates away from them.
-
-  @class Enumerable
-  @private
-*/
-
-export default Mixin.create();
+const Enumerable = Mixin.create();
+export default Enumerable;

package/dist/packages/@ember/-internals/runtime/lib/mixins/evented.js

@@ -1,62 +1,17 @@
 import { Mixin, addListener, removeListener, hasListeners, sendEvent } from '@ember/-internals/metal';
-/**
-@module @ember/object
-*/
-
-/**
-  This mixin allows for Ember objects to subscribe to and emit events.
-
-  ```app/utils/person.js
-  import EmberObject from '@ember/object';
-  import Evented from '@ember/object/evented';
-
-  export default EmberObject.extend(Evented, {
-    greet() {
-      // ...
-      this.trigger('greet');
-    }
-  });
-  ```
-
-  ```javascript
-  var person = Person.create();
-
-  person.on('greet', function() {
-    console.log('Our person has greeted');
-  });
-
-  person.greet();
-
-  // outputs: 'Our person has greeted'
-  ```
-
-  You can also chain multiple event subscriptions:
-
-  ```javascript
-  person.on('greet', function() {
-    console.log('Our person has greeted');
-  }).one('greet', function() {
-    console.log('Offer one-time special');
-  }).off('event', this, forgetThis);
-  ```
-
-  @class Evented
-  @public
- */
-
-export default Mixin.create({
+const Evented = Mixin.create({
   /**
     Subscribes to a named event with given function.
-     ```javascript
+       ```javascript
     person.on('didLoad', function() {
       // fired once the person has loaded
     });
     ```
-     An optional target can be passed in as the 2nd argument that will
+       An optional target can be passed in as the 2nd argument that will
     be set as the "this" for the callback. This is a good way to give your
     function access to the object triggering the event. When the target
     parameter is used the callback method becomes the third argument.
-     @method on
+       @method on
     @param {String} name The name of the event
     @param {Object} [target] The "this" binding for the callback
     @param {Function|String} method A function or the name of a function to be called on `target`
@@ -72,10 +27,10 @@ export default Mixin.create({
     Subscribes a function to a named event and then cancels the subscription
     after the first time the event is triggered. It is good to use ``one`` when
     you only care about the first time an event has taken place.
-     This function takes an optional 2nd argument that will become the "this"
+       This function takes an optional 2nd argument that will become the "this"
     value for the callback. When the target parameter is used the callback method
     becomes the third argument.
-     @method one
+       @method one
     @param {String} name The name of the event
     @param {Object} [target] The "this" binding for the callback
     @param {Function|String} method A function or the name of a function to be called on `target`
@@ -91,12 +46,12 @@ export default Mixin.create({
     Triggers a named event for the object. Any additional arguments
     will be passed as parameters to the functions that are subscribed to the
     event.
-     ```javascript
+       ```javascript
     person.on('didEat', function(food) {
       console.log('person ate some ' + food);
     });
-     person.trigger('didEat', 'broccoli');
-     // outputs: person ate some broccoli
+       person.trigger('didEat', 'broccoli');
+       // outputs: person ate some broccoli
     ```
     @method trigger
     @param {String} name The name of the event
@@ -109,7 +64,7 @@ export default Mixin.create({
 
   /**
     Cancels subscription for given name, target, and method.
-     @method off
+       @method off
     @param {String} name The name of the event
     @param {Object} target The target of the subscription
     @param {Function|String} method The function or the name of a function of the subscription
@@ -123,7 +78,7 @@ export default Mixin.create({
 
   /**
     Checks to see if object has any subscriptions for named event.
-     @method has
+       @method has
     @param {String} name The name of the event
     @return {Boolean} does the object have a subscription for event
     @public
@@ -132,4 +87,5 @@ export default Mixin.create({
     return hasListeners(this, name);
   }
 
-});
+});
+export default Evented;

package/dist/packages/@ember/-internals/runtime/lib/mixins/mutable_enumerable.js

@@ -1,18 +1,4 @@
 import Enumerable from './enumerable';
 import { Mixin } from '@ember/-internals/metal';
-/**
-@module ember
-*/
-
-/**
-  The methods in this mixin have been moved to MutableArray. This mixin has
-  been intentionally preserved to avoid breaking MutableEnumerable.detect
-  checks until the community migrates away from them.
-
-  @class MutableEnumerable
-  @namespace Ember
-  @uses Enumerable
-  @private
-*/
-
-export default Mixin.create(Enumerable);
+const MutableEnumerable = Mixin.create(Enumerable);
+export default MutableEnumerable;