ember-source 4.3.0-alpha.3 → 4.4.0-alpha.2

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/utils/index.js

@@ -507,6 +507,8 @@ function inspectObject(obj, depth, seen) {
     }
 
     let key = keys[i];
+    assert('has key', key); // Looping over array
+
     s += `${inspectKey(key)}: ${inspectValue(obj[key], depth, seen)}`;
   }
 
@@ -571,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

@@ -27,6 +27,7 @@ export function getRootViews(owner) {
   let rootViews = [];
   Object.keys(registry).forEach(id => {
     let view = registry[id];
+    assert('expected view', view);
 
     if (view.parentView === null) {
       rootViews.push(view);

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) {

package/dist/packages/@ember/canary-features/index.js

@@ -13,11 +13,6 @@ import { ENV } from '@ember/-internals/environment';
 export const DEFAULT_FEATURES = {
   EMBER_LIBRARIES_ISREGISTERED: null,
   EMBER_IMPROVED_INSTRUMENTATION: null,
-  EMBER_NAMED_BLOCKS: true,
-  EMBER_GLIMMER_HELPER_MANAGER: true,
-  EMBER_GLIMMER_INVOKE_HELPER: true,
-  EMBER_STRICT_MODE: true,
-  EMBER_DYNAMIC_HELPERS_AND_MODIFIERS: true,
   EMBER_ROUTING_ROUTER_SERVICE_REFRESH: true,
   EMBER_CACHED: true
 };
@@ -70,10 +65,5 @@ function featureValue(value) {
 
 export const EMBER_LIBRARIES_ISREGISTERED = featureValue(FEATURES.EMBER_LIBRARIES_ISREGISTERED);
 export const EMBER_IMPROVED_INSTRUMENTATION = featureValue(FEATURES.EMBER_IMPROVED_INSTRUMENTATION);
-export const EMBER_NAMED_BLOCKS = featureValue(FEATURES.EMBER_NAMED_BLOCKS);
-export const EMBER_GLIMMER_HELPER_MANAGER = featureValue(FEATURES.EMBER_GLIMMER_HELPER_MANAGER);
-export const EMBER_GLIMMER_INVOKE_HELPER = featureValue(FEATURES.EMBER_GLIMMER_INVOKE_HELPER);
-export const EMBER_STRICT_MODE = featureValue(FEATURES.EMBER_STRICT_MODE);
-export const EMBER_DYNAMIC_HELPERS_AND_MODIFIERS = featureValue(FEATURES.EMBER_DYNAMIC_HELPERS_AND_MODIFIERS);
 export const EMBER_ROUTING_ROUTER_SERVICE_REFRESH = featureValue(FEATURES.EMBER_ROUTING_ROUTER_SERVICE_REFRESH);
 export const EMBER_CACHED = featureValue(FEATURES.EMBER_CACHED);

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

@@ -1,61 +1,10 @@
 import { FrameworkObject } from '@ember/-internals/runtime';
 import { inject as metalInject } from '@ember/-internals/metal';
 import ControllerMixin from './lib/controller_mixin';
-/**
-@module @ember/controller
-*/
 
-/**
-  @class Controller
-  @extends EmberObject
-  @uses Ember.ControllerMixin
-  @public
-*/
+class Controller extends FrameworkObject.extend(ControllerMixin) {}
 
-const Controller = FrameworkObject.extend(ControllerMixin);
-/**
-  Creates a property that lazily looks up another controller in the container.
-  Can only be used when defining another controller.
-
-  Example:
-
-  ```app/controllers/post.js
-  import Controller, {
-    inject as controller
-  } from '@ember/controller';
-
-  export default class PostController extends Controller {
-    @controller posts;
-  }
-  ```
-
-  Classic Class Example:
-
-  ```app/controllers/post.js
-  import Controller, {
-    inject as controller
-  } from '@ember/controller';
-
-  export default Controller.extend({
-    posts: controller()
-  });
-  ```
-
-  This example will create a `posts` property on the `post` controller that
-  looks up the `posts` controller in the container, making it easy to reference
-  other controllers.
-
-  @method inject
-  @static
-  @for @ember/controller
-  @since 1.10.0
-  @param {String} name (optional) name of the controller to inject, defaults to
-         the property's name
-  @return {ComputedDecorator} injection decorator instance
-  @public
-*/
-
-export function inject() {
-  return metalInject('controller', ...arguments);
+export function inject(...args) {
+  return metalInject('controller', ...args);
 }
 export default Controller;

package/dist/packages/@ember/debug/lib/capture-render-tree.js

@@ -18,6 +18,8 @@ import { expect } from '@glimmer/util';
 */
 
 export default function captureRenderTree(app) {
+  // SAFETY: Ideally we'd assert here but that causes awkward circular requires since this is also in @ember/debug.
+  // This is only for debug stuff so not very risky.
   let renderer = expect(app.lookup('renderer:-dom'), `BUG: owner is missing renderer`);
   return renderer.debugRenderTree.capture();
 }

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

@@ -2,7 +2,7 @@
 
 /* global console */
 import { ENV } from '@ember/-internals/environment';
-
+import { assert } from '@ember/debug';
 /**
 @module @ember/instrumentation
 @private
@@ -58,16 +58,14 @@ import { ENV } from '@ember/-internals/environment';
   @static
   @private
 */
+
 export let subscribers = [];
 let cache = {};
 
 function populateListeners(name) {
   let listeners = [];
-  let subscriber;
-
-  for (let i = 0; i < subscribers.length; i++) {
-    subscriber = subscribers[i];
 
+  for (let subscriber of subscribers) {
     if (subscriber.regex.test(name)) {
       listeners.push(subscriber.object);
     }
@@ -172,16 +170,17 @@ export function _instrumentStart(name, payloadFunc, payloadArg) {
   let beforeValues = [];
   let timestamp = time();
 
-  for (let i = 0; i < listeners.length; i++) {
-    let listener = listeners[i];
+  for (let listener of listeners) {
     beforeValues.push(listener.before(name, timestamp, payload));
   }
 
+  const constListeners = listeners;
   return function _instrumentEnd() {
     let timestamp = time();
 
-    for (let i = 0; i < listeners.length; i++) {
-      let listener = listeners[i];
+    for (let i = 0; i < constListeners.length; i++) {
+      let listener = constListeners[i];
+      assert('has listener', listener); // Iterating over values
 
       if (typeof listener.after === 'function') {
         listener.after(name, timestamp, payload, beforeValues[i]);
@@ -209,12 +208,9 @@ export function _instrumentStart(name, payloadFunc, payloadArg) {
 
 export function subscribe(pattern, object) {
   let paths = pattern.split('.');
-  let path;
   let regexes = [];
 
-  for (let i = 0; i < paths.length; i++) {
-    path = paths[i];
-
+  for (let path of paths) {
     if (path === '*') {
       regexes.push('[^\\.]*');
     } else {

package/dist/packages/@ember/routing/router-service.js

@@ -0,0 +1 @@
+export { RouterService as default } from '@ember/-internals/routing';

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

@@ -1,74 +1,10 @@
 import { FrameworkObject } from '@ember/-internals/runtime';
 import { inject as metalInject } from '@ember/-internals/metal';
-/**
- @module @ember/service
- @public
- */
-
-/**
-  @method inject
-  @static
-  @since 1.10.0
-  @for @ember/service
-  @param {String} name (optional) name of the service to inject, defaults to
-         the property's name
-  @return {ComputedDecorator} injection decorator instance
-  @public
-*/
-
-export function inject() {
-  return metalInject('service', ...arguments);
+export function inject(...args) {
+  return metalInject('service', ...args);
 }
-/**
-  Creates a property that lazily looks up a service in the container. There are
-  no restrictions as to what objects a service can be injected into.
-
-  Example:
-
-  ```app/routes/application.js
-  import Route from '@ember/routing/route';
-  import { service } from '@ember/service';
-
-  export default class ApplicationRoute extends Route {
-    @service('auth') authManager;
-
-    model() {
-      return this.authManager.findCurrentUser();
-    }
-  }
-  ```
-
-  Classic Class Example:
-
-  ```app/routes/application.js
-  import Route from '@ember/routing/route';
-  import { service } from '@ember/service';
-
-  export default Route.extend({
-    authManager: service('auth'),
-
-    model() {
-      return this.get('authManager').findCurrentUser();
-    }
-  });
-  ```
-
-  This example will create an `authManager` property on the application route
-  that looks up the `auth` service in the container, making it easily accessible
-  in the `model` hook.
-
-  @method service
-  @static
-  @since 4.1.0
-  @for @ember/service
-  @param {String} name (optional) name of the service to inject, defaults to
-         the property's name
-  @return {ComputedDecorator} injection decorator instance
-  @public
-*/
-
-export function service() {
-  return metalInject('service', ...arguments);
+export function service(...args) {
+  return metalInject('service', ...args);
 }
 /**
   @class Service
@@ -77,8 +13,5 @@ export function service() {
   @public
 */
 
-const Service = FrameworkObject.extend();
-Service.reopenClass({
-  isServiceFactory: true
-});
-export default Service;
+export default class Service extends FrameworkObject {}
+Service.isServiceFactory = true;

package/dist/packages/ember/index.js

@@ -313,20 +313,9 @@ Ember._concat = concat;
 Ember._get = get;
 Ember._on = on;
 Ember._fn = fn;
-
-if (true
-/* EMBER_GLIMMER_HELPER_MANAGER */
-) {
-  Ember._helperManagerCapabilities = helperCapabilities;
-  Ember._setHelperManager = setHelperManager;
-}
-
-if (true
-/* EMBER_GLIMMER_INVOKE_HELPER */
-) {
-  Ember._invokeHelper = invokeHelper;
-}
-
+Ember._helperManagerCapabilities = helperCapabilities;
+Ember._setHelperManager = setHelperManager;
+Ember._invokeHelper = invokeHelper;
 Ember._captureRenderTree = captureRenderTree;
 
 const deprecateImportFromString = function (name, message = `Importing ${name} from '@ember/string' is deprecated. Please import ${name} from '@ember/template' instead.`) {

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.3.0-alpha.3";
+export default "4.4.0-alpha.2";