ember-source 4.4.0-alpha.1 → 4.4.0-alpha.4

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

@@ -53,7 +53,7 @@ function customTagForProxy(proxy, key, addMandatorySetter) {
 export default Mixin.create({
   /**
     The object whose properties will be forwarded.
-       @property content
+     @property content
     @type {unknown}
     @default null
     @public

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

@@ -1351,7 +1351,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
     colors.unshiftObjects('yellow'); // Type Error: 'undefined' is not a function
     ```
      @method unshiftObjects
-    @param {Enumberable} objects the objects to add
+    @param {Enumerable} objects the objects to add
     @return {EmberArray} receiver
     @public
   */

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

@@ -18,13 +18,13 @@ import { Mixin } from '@ember/-internals/metal';
 export default 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

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

@@ -15,7 +15,7 @@ import { Mixin } from '@ember/-internals/metal';
 let containerProxyMixin = {
   /**
    The container stores state.
-      @private
+    @private
    @property {Ember.Container} __container__
    */
   __container__: null,
@@ -23,16 +23,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 +43,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,32 +91,32 @@ 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

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

@@ -98,7 +98,7 @@ export default Mixin.create({
   /**
     If the proxied promise is rejected this will contain the reason
     provided.
-       @property reason
+     @property reason
     @default null
     @public
   */
@@ -106,7 +106,7 @@ export default Mixin.create({
 
   /**
     Once the proxied promise has settled this will become `false`.
-       @property isPending
+     @property isPending
     @default true
     @public
   */
@@ -116,7 +116,7 @@ export default Mixin.create({
 
   /**
     Once the proxied promise has settled this will become `true`.
-       @property isSettled
+     @property isSettled
     @default false
     @public
   */
@@ -126,7 +126,7 @@ export default Mixin.create({
 
   /**
     Will become `true` if the proxied promise is rejected.
-       @property isRejected
+     @property isRejected
     @default false
     @public
   */
@@ -134,7 +134,7 @@ export default Mixin.create({
 
   /**
     Will become `true` if the proxied promise is fulfilled.
-       @property isFulfilled
+     @property isFulfilled
     @default false
     @public
   */
@@ -142,17 +142,17 @@ export default Mixin.create({
 
   /**
     The promise whose fulfillment value is being proxied by this object.
-       This property must be specified upon creation, and should not be
+     This property must be specified upon creation, and should not be
     changed once created.
-       Example:
-       ```javascript
+     Example:
+     ```javascript
     import ObjectProxy from '@ember/object/proxy';
     import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-       ObjectProxy.extend(PromiseProxyMixin).create({
+     ObjectProxy.extend(PromiseProxyMixin).create({
       promise: <thenable>
     });
     ```
-       @property promise
+     @property promise
     @public
   */
   promise: computed({
@@ -168,8 +168,8 @@ export default Mixin.create({
 
   /**
     An alias to the proxied promise's `then`.
-       See RSVP.Promise.then.
-       @method then
+     See RSVP.Promise.then.
+     @method then
     @param {Function} callback
     @return {RSVP.Promise}
     @public
@@ -178,8 +178,8 @@ export default Mixin.create({
 
   /**
     An alias to the proxied promise's `catch`.
-       See RSVP.Promise.catch.
-       @method catch
+     See RSVP.Promise.catch.
+     @method catch
     @param {Function} callback
     @return {RSVP.Promise}
     @since 1.3.0
@@ -189,8 +189,8 @@ export default Mixin.create({
 
   /**
     An alias to the proxied promise's `finally`.
-       See RSVP.Promise.finally.
-       @method finally
+     See RSVP.Promise.finally.
+     @method finally
     @param {Function} callback
     @return {RSVP.Promise}
     @since 1.3.0

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

@@ -16,62 +16,62 @@ export default Mixin.create({
 
   /**
    Given a fullName return the corresponding factory.
-      @public
+    @public
    @method resolveRegistration
    @param {String} fullName
    @return {Function} fullName's factory
    */
-  resolveRegistration(fullName, options) {
+  resolveRegistration(fullName) {
     assert('fullName must be a proper full name', this.__registry__.isValidFullName(fullName));
-    return this.__registry__.resolve(fullName, options);
+    return this.__registry__.resolve(fullName);
   },
 
   /**
     Registers a factory that can be used for dependency injection (with
     `inject`) or for service lookup. Each factory is registered with
     a full name including two parts: `type:name`.
-       A simple example:
-       ```javascript
+     A simple example:
+     ```javascript
     import Application from '@ember/application';
     import EmberObject from '@ember/object';
-       let App = Application.create();
-       App.Orange = EmberObject.extend();
+     let App = Application.create();
+     App.Orange = EmberObject.extend();
     App.register('fruit:favorite', App.Orange);
     ```
-       Ember will resolve factories from the `App` namespace automatically.
+     Ember will resolve factories from the `App` namespace automatically.
     For example `App.CarsController` will be discovered and returned if
     an application requests `controller:cars`.
-       An example of registering a controller with a non-standard name:
-       ```javascript
+     An example of registering a controller with a non-standard name:
+     ```javascript
     import Application from '@ember/application';
     import Controller from '@ember/controller';
-       let App = Application.create();
+     let App = Application.create();
     let Session = Controller.extend();
-       App.register('controller:session', Session);
-       // The Session controller can now be treated like a normal controller,
+     App.register('controller:session', Session);
+     // The Session controller can now be treated like a normal controller,
     // despite its non-standard name.
     App.ApplicationController = Controller.extend({
       needs: ['session']
     });
     ```
-       Registered factories are **instantiated** by having `create`
+     Registered factories are **instantiated** by having `create`
     called on them. Additionally they are **singletons**, each time
     they are looked up they return the same instance.
-       Some examples modifying that default behavior:
-       ```javascript
+     Some examples modifying that default behavior:
+     ```javascript
     import Application from '@ember/application';
     import EmberObject from '@ember/object';
-       let App = Application.create();
-       App.Person = EmberObject.extend();
+     let App = Application.create();
+     App.Person = EmberObject.extend();
     App.Orange = EmberObject.extend();
     App.Email = EmberObject.extend();
     App.session = EmberObject.create();
-       App.register('model:user', App.Person, { singleton: false });
+     App.register('model:user', App.Person, { singleton: false });
     App.register('fruit:favorite', App.Orange);
     App.register('communication:main', App.Email, { singleton: false });
     App.register('session', App.session, { instantiate: false });
     ```
-       @method register
+     @method register
     @param  fullName {String} type:name (e.g., 'model:user')
     @param  factory {any} (e.g., App.Person)
     @param  options {Object} (optional) disable instantiation or singleton usage
@@ -81,17 +81,17 @@ export default Mixin.create({
 
   /**
    Unregister a factory.
-      ```javascript
+    ```javascript
    import Application from '@ember/application';
    import EmberObject from '@ember/object';
-      let App = Application.create();
+    let App = Application.create();
    let User = EmberObject.extend();
    App.register('model:user', User);
-      App.resolveRegistration('model:user').create() instanceof User //=> true
-      App.unregister('model:user')
+    App.resolveRegistration('model:user').create() instanceof User //=> true
+    App.unregister('model:user')
    App.resolveRegistration('model:user') === undefined //=> true
    ```
-      @public
+    @public
    @method unregister
    @param {String} fullName
    */
@@ -99,7 +99,7 @@ export default Mixin.create({
 
   /**
    Check if a factory is registered.
-      @public
+    @public
    @method hasRegistration
    @param {String} fullName
    @return {Boolean}
@@ -108,7 +108,7 @@ export default Mixin.create({
 
   /**
    Return a specific registered option for a particular factory.
-      @public
+    @public
    @method registeredOption
    @param  {String} fullName
    @param  {String} optionName
@@ -118,7 +118,7 @@ export default Mixin.create({
 
   /**
    Register options for a particular factory.
-      @public
+    @public
    @method registerOptions
    @param {String} fullName
    @param {Object} options
@@ -127,7 +127,7 @@ export default Mixin.create({
 
   /**
    Return registered options for a particular factory.
-      @public
+    @public
    @method registeredOptions
    @param  {String} fullName
    @return {Object} options
@@ -136,22 +136,22 @@ export default Mixin.create({
 
   /**
    Allow registering options for all factories of a type.
-      ```javascript
+    ```javascript
    import Application from '@ember/application';
-      let App = Application.create();
+    let App = Application.create();
    let appInstance = App.buildInstance();
-      // if all of type `connection` must not be singletons
+    // if all of type `connection` must not be singletons
    appInstance.registerOptionsForType('connection', { singleton: false });
-      appInstance.register('connection:twitter', TwitterConnection);
+    appInstance.register('connection:twitter', TwitterConnection);
    appInstance.register('connection:facebook', FacebookConnection);
-      let twitter = appInstance.lookup('connection:twitter');
+    let twitter = appInstance.lookup('connection:twitter');
    let twitter2 = appInstance.lookup('connection:twitter');
-      twitter === twitter2; // => false
-      let facebook = appInstance.lookup('connection:facebook');
+    twitter === twitter2; // => false
+    let facebook = appInstance.lookup('connection:facebook');
    let facebook2 = appInstance.lookup('connection:facebook');
-      facebook === facebook2; // => false
+    facebook === facebook2; // => false
    ```
-      @public
+    @public
    @method registerOptionsForType
    @param {String} type
    @param {Object} options
@@ -160,7 +160,7 @@ export default Mixin.create({
 
   /**
    Return the registered options for all factories of a type.
-      @public
+    @public
    @method registeredOptionsForType
    @param {String} type
    @return {Object} options
@@ -170,41 +170,42 @@ export default Mixin.create({
   /**
     Define a dependency injection onto a specific factory or all factories
     of a type.
-       When Ember instantiates a controller, view, or other framework component
+     When Ember instantiates a controller, view, or other framework component
     it can attach a dependency to that component. This is often used to
     provide services to a set of framework components.
-       An example of providing a session object to all controllers:
-       ```javascript
+     An example of providing a session object to all controllers:
+     ```javascript
     import { alias } from '@ember/object/computed';
     import Application from '@ember/application';
     import Controller from '@ember/controller';
     import EmberObject from '@ember/object';
-       let App = Application.create();
+     let App = Application.create();
     let Session = EmberObject.extend({ isAuthenticated: false });
-       // A factory must be registered before it can be injected
+     // A factory must be registered before it can be injected
     App.register('session:main', Session);
-       // Inject 'session:main' onto all factories of the type 'controller'
+     // Inject 'session:main' onto all factories of the type 'controller'
     // with the name 'session'
     App.inject('controller', 'session', 'session:main');
-       App.IndexController = Controller.extend({
+     App.IndexController = Controller.extend({
       isLoggedIn: alias('session.isAuthenticated')
     });
     ```
-       Injections can also be performed on specific factories.
-       ```javascript
+     Injections can also be performed on specific factories.
+     ```javascript
     App.inject(<full_name or type>, <property name>, <full_name>)
     App.inject('route', 'source', 'source:main')
     App.inject('route:application', 'email', 'model:email')
     ```
-       It is important to note that injections can only be performed on
+     It is important to note that injections can only be performed on
     classes that are instantiated by Ember itself. Instantiating a class
     directly (via `create` or `new`) bypasses the dependency injection
     system.
-       @public
+     @public
     @method inject
     @param  factoryNameOrType {String}
     @param  property {String}
     @param  injectionName {String}
+    @deprecated
   **/
   inject: registryAlias('injection')
 });

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

@@ -41,9 +41,9 @@ const TargetActionSupport = Mixin.create({
   /**
   Send an `action` with an `actionContext` to a `target`. The action, actionContext
   and target will be retrieved from properties of the object. For example:
-     ```javascript
+   ```javascript
   import { alias } from '@ember/object/computed';
-     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
     target: alias('controller'),
     action: 'save',
     actionContext: alias('context'),
@@ -53,9 +53,9 @@ const TargetActionSupport = Mixin.create({
     }
   });
   ```
-     The `target`, `action`, and `actionContext` can be provided as properties of
+   The `target`, `action`, and `actionContext` can be provided as properties of
   an optional object argument to `triggerAction` as well.
-     ```javascript
+   ```javascript
   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
     click() {
       this.triggerAction({
@@ -67,12 +67,12 @@ const TargetActionSupport = Mixin.create({
     }
   });
   ```
-     The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
+   The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
   But `target` and `action` must be specified either as properties or with the argument
   to `triggerAction`, or a combination:
-     ```javascript
+   ```javascript
   import { alias } from '@ember/object/computed';
-     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
     target: alias('controller'),
     click() {
       this.triggerAction({
@@ -82,7 +82,7 @@ const TargetActionSupport = Mixin.create({
     }
   });
   ```
-     @method triggerAction
+   @method triggerAction
   @param opts {Object} (optional, with the optional keys action, target and/or actionContext)
   @return {Boolean} true if the action was sent successfully and did not return false
   @private

package/dist/packages/@ember/-internals/utils/index.js

@@ -573,7 +573,7 @@ function lookupDescriptor(obj, keyName) {
   @private
 */
 function canInvoke(obj, methodName) {
-  return obj !== null && obj !== undefined && typeof obj[methodName] === 'function';
+  return obj != null && typeof obj[methodName] === 'function';
 }
 /**
   @module @ember/utils

package/dist/packages/@ember/-internals/views/lib/system/utils.js

@@ -1,6 +1,4 @@
 import { getOwner } from '@ember/-internals/owner';
-/* globals Element */
-
 import { guidFor } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 /**
@@ -8,6 +6,10 @@ import { assert } from '@ember/debug';
 */
 
 export function isSimpleClick(event) {
+  if (!(event instanceof MouseEvent)) {
+    return false;
+  }
+
   let modifier = event.shiftKey || event.metaKey || event.altKey || event.ctrlKey;
   let secondaryClick = event.which > 1; // IE9 may return undefined
 

package/dist/packages/@ember/-internals/views/lib/views/core_view.js

@@ -1,23 +1,6 @@
 import { inject } from '@ember/-internals/metal';
 import { ActionHandler, Evented, FrameworkObject } from '@ember/-internals/runtime';
 import states from './states';
-/**
-  `Ember.CoreView` is an abstract class that exists to give view-like behavior
-  to both Ember's main view class `Component` and other classes that don't need
-  the full functionality of `Component`.
-
-  Unless you have specific needs for `CoreView`, you will use `Component`
-  in your applications.
-
-  @class CoreView
-  @namespace Ember
-  @extends EmberObject
-  @deprecated Use `Component` instead.
-  @uses Evented
-  @uses Ember.ActionHandler
-  @private
-*/
-
 const CoreView = FrameworkObject.extend(Evented, ActionHandler, {
   isView: true,
   _states: states,
@@ -34,7 +17,7 @@ const CoreView = FrameworkObject.extend(Evented, ActionHandler, {
   /**
     If the view is currently inserted into the DOM of a parent view, this
     property will point to the parent of the view.
-     @property parentView
+       @property parentView
     @type Ember.View
     @default null
     @private
@@ -42,16 +25,16 @@ const CoreView = FrameworkObject.extend(Evented, ActionHandler, {
   parentView: null,
 
   instrumentDetails(hash) {
-    hash.object = this.toString();
-    hash.containerKey = this._debugContainerKey;
-    hash.view = this;
+    hash['object'] = this.toString();
+    hash['containerKey'] = this._debugContainerKey;
+    hash['view'] = this;
     return hash;
   },
 
   /**
     Override the default event firing from `Evented` to
     also call methods with the given name.
-     @method trigger
+       @method trigger
     @param name {String}
     @private
   */

package/dist/packages/@ember/application/instance.js

@@ -308,12 +308,12 @@ class BootOptions {
       @default auto-detected
       @private
     */
-    this.isInteractive = environment.hasDOM; // This default is overridable below
+    this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
 
     /**
       @property _renderMode
       @type string
-      @default false
+      @default undefined
       @private
     */
 
@@ -340,7 +340,7 @@ class BootOptions {
     if (options.isBrowser !== undefined) {
       this.isBrowser = Boolean(options.isBrowser);
     } else {
-      this.isBrowser = environment.hasDOM;
+      this.isBrowser = Boolean(environment.hasDOM);
     }
 
     if (!this.isBrowser) {