ember-source 4.4.0-alpha.7 → 4.5.0-alpha.2

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

@@ -1,7 +1,7 @@
 export { getEngineParent, setEngineParent } from './lib/engine-parent';
 import { canInvoke } from '@ember/-internals/utils';
 import Controller from '@ember/controller';
-import { Namespace, RegistryProxyMixin } from '@ember/-internals/runtime';
+import { Namespace } from '@ember/-internals/runtime';
 import { Registry } from '@ember/-internals/container';
 import DAG from 'dag-map';
 import { assert } from '@ember/debug';
@@ -11,6 +11,7 @@ import { RoutingService } from '@ember/-internals/routing';
 import { ContainerDebugAdapter } from '@ember/-internals/extension-support';
 import { ComponentLookup } from '@ember/-internals/views';
 import { setupEngineRegistry } from '@ember/-internals/glimmer';
+import RegistryProxyMixin from '@ember/-internals/runtime/lib/mixins/registry_proxy';
 
 function props(obj) {
   let properties = [];
@@ -21,115 +22,141 @@ function props(obj) {
 
   return properties;
 }
-/**
-@module @ember/engine
-*/
-
-/**
-  The `Engine` class contains core functionality for both applications and
-  engines.
-
-  Each engine manages a registry that's used for dependency injection and
-  exposed through `RegistryProxy`.
-
-  Engines also manage initializers and instance initializers.
 
-  Engines can spawn `EngineInstance` instances via `buildInstance()`.
+class Engine extends Namespace.extend(RegistryProxyMixin) {
+  constructor() {
+    super(...arguments);
+    /**
+      A private flag indicating whether an engine's initializers have run yet.
+             @private
+      @property _initializersRan
+    */
 
-  @class Engine
-  @extends Ember.Namespace
-  @uses RegistryProxy
-  @public
-*/
+    this._initializersRan = false;
+  }
+  /**
+    This creates a registry with the default Ember naming conventions.
+       It also configures the registry:
+       * registered views are created every time they are looked up (they are
+      not singletons)
+    * registered templates are not factories; the registered value is
+      returned directly.
+    * the router receives the application as its `namespace` property
+    * all controllers receive the router as their `target` and `controllers`
+      properties
+    * all controllers receive the application as their `namespace` property
+    * the application view receives the application controller as its
+      `controller` property
+    * the application view receives the application template as its
+      `defaultTemplate` property
+       @method buildRegistry
+    @static
+    @param {Application} namespace the application for which to
+      build the registry
+    @return {Ember.Registry} the built registry
+    @private
+  */
 
 
-const Engine = Namespace.extend(RegistryProxyMixin, {
-  init() {
-    this._super(...arguments);
+  static buildRegistry(namespace) {
+    let registry = new Registry({
+      resolver: resolverFor(namespace)
+    });
+    registry.set = set;
+    registry.register('application:main', namespace, {
+      instantiate: false
+    });
+    commonSetupRegistry(registry);
+    setupEngineRegistry(registry);
+    return registry;
+  }
 
+  init(properties) {
+    super.init(properties);
     this.buildRegistry();
-  },
-
-  /**
-    A private flag indicating whether an engine's initializers have run yet.
-     @private
-    @property _initializersRan
-  */
-  _initializersRan: false,
-
+  }
   /**
     Ensure that initializers are run once, and only once, per engine.
-     @private
+       @private
     @method ensureInitializers
   */
+
+
   ensureInitializers() {
     if (!this._initializersRan) {
       this.runInitializers();
       this._initializersRan = true;
     }
-  },
-
+  }
   /**
     Create an EngineInstance for this engine.
-     @public
+       @public
     @method buildInstance
     @return {EngineInstance} the engine instance
   */
+
+
   buildInstance(options = {}) {
     this.ensureInitializers();
-    options.base = this;
-    return EngineInstance.create(options);
-  },
-
+    return EngineInstance.create(Object.assign(Object.assign({}, options), {
+      base: this
+    }));
+  }
   /**
     Build and configure the registry for the current engine.
-     @private
+       @private
     @method buildRegistry
     @return {Ember.Registry} the configured registry
   */
+
+
   buildRegistry() {
     let registry = this.__registry__ = this.constructor.buildRegistry(this);
     return registry;
-  },
-
+  }
   /**
     @private
     @method initializer
   */
-  initializer(options) {
-    this.constructor.initializer(options);
-  },
 
+
+  initializer(initializer) {
+    this.constructor.initializer(initializer);
+  }
   /**
     @private
     @method instanceInitializer
   */
-  instanceInitializer(options) {
-    this.constructor.instanceInitializer(options);
-  },
 
+
+  instanceInitializer(initializer) {
+    this.constructor.instanceInitializer(initializer);
+  }
   /**
     @private
     @method runInitializers
   */
+
+
   runInitializers() {
     this._runInitializer('initializers', (name, initializer) => {
-      assert(`No application initializer named '${name}'`, Boolean(initializer));
+      assert(`No application initializer named '${name}'`, initializer);
       initializer.initialize(this);
     });
-  },
-
+  }
   /**
     @private
     @since 1.12.0
     @method runInstanceInitializers
   */
+
+
   runInstanceInitializers(instance) {
     this._runInitializer('instanceInitializers', (name, initializer) => {
-      assert(`No instance initializer named '${name}'`, Boolean(initializer));
+      assert(`No instance initializer named '${name}'`, initializer);
       initializer.initialize(instance);
     });
-  },
+  }
 
   _runInitializer(bucketName, cb) {
     let initializersByName = get(this.constructor, bucketName);
@@ -137,232 +164,238 @@ const Engine = Namespace.extend(RegistryProxyMixin, {
     let graph = new DAG();
     let initializer;
 
-    for (let i = 0; i < initializers.length; i++) {
-      initializer = initializersByName[initializers[i]];
+    for (let name of initializers) {
+      initializer = initializersByName[name];
+      assert(`missing ${bucketName}: ${name}`, initializer);
       graph.add(initializer.name, initializer, initializer.before, initializer.after);
     }
 
     graph.topsort(cb);
   }
 
-});
-Engine.reopenClass({
-  initializers: Object.create(null),
-  instanceInitializers: Object.create(null),
+}
 
-  /**
-    The goal of initializers should be to register dependencies and injections.
-    This phase runs once. Because these initializers may load code, they are
-    allowed to defer application readiness and advance it. If you need to access
-    the container or store you should use an InstanceInitializer that will be run
-    after all initializers and therefore after all code is loaded and the app is
-    ready.
-     Initializer receives an object which has the following attributes:
-    `name`, `before`, `after`, `initialize`. The only required attribute is
-    `initialize`, all others are optional.
-     * `name` allows you to specify under which name the initializer is registered.
-    This must be a unique name, as trying to register two initializers with the
-    same name will result in an error.
-     ```app/initializer/named-initializer.js
-    import { debug } from '@ember/debug';
-     export function initialize() {
-      debug('Running namedInitializer!');
-    }
-     export default {
-      name: 'named-initializer',
-      initialize
-    };
-    ```
-     * `before` and `after` are used to ensure that this initializer is ran prior
-    or after the one identified by the value. This value can be a single string
-    or an array of strings, referencing the `name` of other initializers.
-     An example of ordering initializers, we create an initializer named `first`:
-     ```app/initializer/first.js
-    import { debug } from '@ember/debug';
-     export function initialize() {
-      debug('First initializer!');
-    }
-     export default {
-      name: 'first',
-      initialize
-    };
-    ```
-     ```bash
-    // DEBUG: First initializer!
-    ```
-     We add another initializer named `second`, specifying that it should run
-    after the initializer named `first`:
-     ```app/initializer/second.js
-    import { debug } from '@ember/debug';
-     export function initialize() {
-      debug('Second initializer!');
-    }
-     export default {
-      name: 'second',
-      after: 'first',
-      initialize
-    };
-    ```
-     ```
-    // DEBUG: First initializer!
-    // DEBUG: Second initializer!
-    ```
-     Afterwards we add a further initializer named `pre`, this time specifying
-    that it should run before the initializer named `first`:
-     ```app/initializer/pre.js
-    import { debug } from '@ember/debug';
-     export function initialize() {
-      debug('Pre initializer!');
-    }
-     export default {
-      name: 'pre',
-      before: 'first',
-      initialize
-    };
-    ```
-     ```bash
-    // DEBUG: Pre initializer!
-    // DEBUG: First initializer!
-    // DEBUG: Second initializer!
-    ```
-     Finally we add an initializer named `post`, specifying it should run after
-    both the `first` and the `second` initializers:
-     ```app/initializer/post.js
-    import { debug } from '@ember/debug';
-     export function initialize() {
-      debug('Post initializer!');
-    }
-     export default {
-      name: 'post',
-      after: ['first', 'second'],
-      initialize
-    };
-    ```
-     ```bash
-    // DEBUG: Pre initializer!
-    // DEBUG: First initializer!
-    // DEBUG: Second initializer!
-    // DEBUG: Post initializer!
-    ```
-     * `initialize` is a callback function that receives one argument,
-      `application`, on which you can operate.
-     Example of using `application` to register an adapter:
-     ```app/initializer/api-adapter.js
-    import ApiAdapter from '../utils/api-adapter';
-     export function initialize(application) {
-      application.register('api-adapter:main', ApiAdapter);
-    }
-     export default {
-      name: 'post',
-      after: ['first', 'second'],
-      initialize
-    };
-    ```
-     @method initializer
-    @param initializer {Object}
-    @public
-  */
-  initializer: buildInitializerMethod('initializers', 'initializer'),
+Engine.initializers = Object.create(null);
+Engine.instanceInitializers = Object.create(null);
+/**
+  The goal of initializers should be to register dependencies and injections.
+  This phase runs once. Because these initializers may load code, they are
+  allowed to defer application readiness and advance it. If you need to access
+  the container or store you should use an InstanceInitializer that will be run
+  after all initializers and therefore after all code is loaded and the app is
+  ready.
+
+  Initializer receives an object which has the following attributes:
+  `name`, `before`, `after`, `initialize`. The only required attribute is
+  `initialize`, all others are optional.
+
+  * `name` allows you to specify under which name the initializer is registered.
+  This must be a unique name, as trying to register two initializers with the
+  same name will result in an error.
+
+  ```app/initializer/named-initializer.js
+  import { debug } from '@ember/debug';
+
+  export function initialize() {
+    debug('Running namedInitializer!');
+  }
 
-  /**
-    Instance initializers run after all initializers have run. Because
-    instance initializers run after the app is fully set up. We have access
-    to the store, container, and other items. However, these initializers run
-    after code has loaded and are not allowed to defer readiness.
-     Instance initializer receives an object which has the following attributes:
-    `name`, `before`, `after`, `initialize`. The only required attribute is
-    `initialize`, all others are optional.
-     * `name` allows you to specify under which name the instanceInitializer is
-    registered. This must be a unique name, as trying to register two
-    instanceInitializer with the same name will result in an error.
-     ```app/initializer/named-instance-initializer.js
-    import { debug } from '@ember/debug';
-     export function initialize() {
-      debug('Running named-instance-initializer!');
-    }
-     export default {
-      name: 'named-instance-initializer',
-      initialize
-    };
-    ```
-     * `before` and `after` are used to ensure that this initializer is ran prior
-    or after the one identified by the value. This value can be a single string
-    or an array of strings, referencing the `name` of other initializers.
-     * See Application.initializer for discussion on the usage of before
-    and after.
-     Example instanceInitializer to preload data into the store.
-     ```app/initializer/preload-data.js
-     export function initialize(application) {
-        var userConfig, userConfigEncoded, store;
-        // We have a HTML escaped JSON representation of the user's basic
-        // configuration generated server side and stored in the DOM of the main
-        // index.html file. This allows the app to have access to a set of data
-        // without making any additional remote calls. Good for basic data that is
-        // needed for immediate rendering of the page. Keep in mind, this data,
-        // like all local models and data can be manipulated by the user, so it
-        // should not be relied upon for security or authorization.
-         // Grab the encoded data from the meta tag
-        userConfigEncoded = document.querySelector('head meta[name=app-user-config]').attr('content');
-         // Unescape the text, then parse the resulting JSON into a real object
-        userConfig = JSON.parse(unescape(userConfigEncoded));
-         // Lookup the store
-        store = application.lookup('service:store');
-         // Push the encoded JSON into the store
-        store.pushPayload(userConfig);
-    }
-     export default {
-      name: 'named-instance-initializer',
-      initialize
-    };
-    ```
-     @method instanceInitializer
-    @param instanceInitializer
-    @public
-  */
-  instanceInitializer: buildInitializerMethod('instanceInitializers', 'instance initializer'),
+  export default {
+    name: 'named-initializer',
+    initialize
+  };
+  ```
 
-  /**
-    This creates a registry with the default Ember naming conventions.
-     It also configures the registry:
-     * registered views are created every time they are looked up (they are
-      not singletons)
-    * registered templates are not factories; the registered value is
-      returned directly.
-    * the router receives the application as its `namespace` property
-    * all controllers receive the router as their `target` and `controllers`
-      properties
-    * all controllers receive the application as their `namespace` property
-    * the application view receives the application controller as its
-      `controller` property
-    * the application view receives the application template as its
-      `defaultTemplate` property
-     @method buildRegistry
-    @static
-    @param {Application} namespace the application for which to
-      build the registry
-    @return {Ember.Registry} the built registry
-    @private
-  */
-  buildRegistry(namespace) {
-    let registry = new Registry({
-      resolver: resolverFor(namespace)
-    });
-    registry.set = set;
-    registry.register('application:main', namespace, {
-      instantiate: false
-    });
-    commonSetupRegistry(registry);
-    setupEngineRegistry(registry);
-    return registry;
-  },
+  * `before` and `after` are used to ensure that this initializer is ran prior
+  or after the one identified by the value. This value can be a single string
+  or an array of strings, referencing the `name` of other initializers.
 
-  /**
-    Set this to provide an alternate class to `DefaultResolver`
-     @property resolver
-    @public
-  */
-  Resolver: null
-});
+  An example of ordering initializers, we create an initializer named `first`:
+
+  ```app/initializer/first.js
+  import { debug } from '@ember/debug';
+
+  export function initialize() {
+    debug('First initializer!');
+  }
+
+  export default {
+    name: 'first',
+    initialize
+  };
+  ```
+
+  ```bash
+  // DEBUG: First initializer!
+  ```
+
+  We add another initializer named `second`, specifying that it should run
+  after the initializer named `first`:
+
+  ```app/initializer/second.js
+  import { debug } from '@ember/debug';
+
+  export function initialize() {
+    debug('Second initializer!');
+  }
+
+  export default {
+    name: 'second',
+    after: 'first',
+    initialize
+  };
+  ```
+
+  ```
+  // DEBUG: First initializer!
+  // DEBUG: Second initializer!
+  ```
+
+  Afterwards we add a further initializer named `pre`, this time specifying
+  that it should run before the initializer named `first`:
+
+  ```app/initializer/pre.js
+  import { debug } from '@ember/debug';
+
+  export function initialize() {
+    debug('Pre initializer!');
+  }
+
+  export default {
+    name: 'pre',
+    before: 'first',
+    initialize
+  };
+  ```
+
+  ```bash
+  // DEBUG: Pre initializer!
+  // DEBUG: First initializer!
+  // DEBUG: Second initializer!
+  ```
+
+  Finally we add an initializer named `post`, specifying it should run after
+  both the `first` and the `second` initializers:
+
+  ```app/initializer/post.js
+  import { debug } from '@ember/debug';
+
+  export function initialize() {
+    debug('Post initializer!');
+  }
+
+  export default {
+    name: 'post',
+    after: ['first', 'second'],
+    initialize
+  };
+  ```
+
+  ```bash
+  // DEBUG: Pre initializer!
+  // DEBUG: First initializer!
+  // DEBUG: Second initializer!
+  // DEBUG: Post initializer!
+  ```
+
+  * `initialize` is a callback function that receives one argument,
+    `application`, on which you can operate.
+
+  Example of using `application` to register an adapter:
+
+  ```app/initializer/api-adapter.js
+  import ApiAdapter from '../utils/api-adapter';
+
+  export function initialize(application) {
+    application.register('api-adapter:main', ApiAdapter);
+  }
+
+  export default {
+    name: 'post',
+    after: ['first', 'second'],
+    initialize
+  };
+  ```
+
+  @method initializer
+  @param initializer {Object}
+  @public
+*/
+
+Engine.initializer = buildInitializerMethod('initializers', 'initializer');
+/**
+  Instance initializers run after all initializers have run. Because
+  instance initializers run after the app is fully set up. We have access
+  to the store, container, and other items. However, these initializers run
+  after code has loaded and are not allowed to defer readiness.
+
+  Instance initializer receives an object which has the following attributes:
+  `name`, `before`, `after`, `initialize`. The only required attribute is
+  `initialize`, all others are optional.
+
+  * `name` allows you to specify under which name the instanceInitializer is
+  registered. This must be a unique name, as trying to register two
+  instanceInitializer with the same name will result in an error.
+
+  ```app/initializer/named-instance-initializer.js
+  import { debug } from '@ember/debug';
+
+  export function initialize() {
+    debug('Running named-instance-initializer!');
+  }
+
+  export default {
+    name: 'named-instance-initializer',
+    initialize
+  };
+  ```
+
+  * `before` and `after` are used to ensure that this initializer is ran prior
+  or after the one identified by the value. This value can be a single string
+  or an array of strings, referencing the `name` of other initializers.
+
+  * See Application.initializer for discussion on the usage of before
+  and after.
+
+  Example instanceInitializer to preload data into the store.
+
+  ```app/initializer/preload-data.js
+
+  export function initialize(application) {
+      var userConfig, userConfigEncoded, store;
+      // We have a HTML escaped JSON representation of the user's basic
+      // configuration generated server side and stored in the DOM of the main
+      // index.html file. This allows the app to have access to a set of data
+      // without making any additional remote calls. Good for basic data that is
+      // needed for immediate rendering of the page. Keep in mind, this data,
+      // like all local models and data can be manipulated by the user, so it
+      // should not be relied upon for security or authorization.
+
+      // Grab the encoded data from the meta tag
+      userConfigEncoded = document.querySelector('head meta[name=app-user-config]').attr('content');
+
+      // Unescape the text, then parse the resulting JSON into a real object
+      userConfig = JSON.parse(unescape(userConfigEncoded));
+
+      // Lookup the store
+      store = application.lookup('service:store');
+
+      // Push the encoded JSON into the store
+      store.pushPayload(userConfig);
+  }
+
+  export default {
+    name: 'named-instance-initializer',
+    initialize
+  };
+  ```
+
+  @method instanceInitializer
+  @param instanceInitializer
+  @public
+*/
+
+Engine.instanceInitializer = buildInitializerMethod('instanceInitializers', 'instance initializer');
 /**
   This function defines the default lookup rules for container lookups:
 
@@ -376,12 +409,12 @@ Engine.reopenClass({
 
   @private
   @method resolverFor
-  @param {Ember.Namespace} namespace the namespace to look for classes
+  @param {Ember.Enginer} namespace the namespace to look for classes
   @return {*} the resolved value for a given lookup
 */
 
 function resolverFor(namespace) {
-  let ResolverClass = get(namespace, 'Resolver');
+  let ResolverClass = namespace.Resolver;
   let props = {
     namespace
   };
@@ -394,16 +427,21 @@ function buildInitializerMethod(bucketName, humanName) {
     // to make sure we have a new `initializers` object, which extends from the parent class' using
     // prototypal inheritance. Without this, attempting to add initializers to the subclass would
     // pollute the parent class as well as other subclasses.
-    if (this.superclass[bucketName] !== undefined && this.superclass[bucketName] === this[bucketName]) {
-      let attrs = {};
-      attrs[bucketName] = Object.create(this[bucketName]);
+    // SAFETY: The superclass may be an Engine, we don't call unless we confirmed it was ok.
+    let superclass = this.superclass;
+
+    if (superclass[bucketName] !== undefined && superclass[bucketName] === this[bucketName]) {
+      let attrs = {
+        [bucketName]: Object.create(this[bucketName])
+      };
       this.reopenClass(attrs);
     }
 
     assert(`The ${humanName} '${initializer.name}' has already been registered`, !this[bucketName][initializer.name]);
     assert(`An ${humanName} cannot be registered without an initialize function`, canInvoke(initializer, 'initialize'));
     assert(`An ${humanName} cannot be registered without a name property`, initializer.name !== undefined);
-    this[bucketName][initializer.name] = initializer;
+    let initializers = this[bucketName];
+    initializers[initializer.name] = initializer;
   };
 }