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

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

@@ -1,10 +1,13 @@
 /**
 @module @ember/application
 */
-import { get, set, computed } from '@ember/-internals/metal';
+import { get, set } from '@ember/-internals/metal';
 import * as environment from '@ember/-internals/browser-environment';
 import EngineInstance from '@ember/engine/instance';
 import { renderSettled } from '@ember/-internals/glimmer';
+import { assert } from '@ember/debug';
+import { Router } from '@ember/-internals/routing';
+import { EventDispatcher } from '@ember/-internals/views';
 /**
   The `ApplicationInstance` encapsulates all of the stateful aspects of a
   running `Application`.
@@ -30,35 +33,21 @@ import { renderSettled } from '@ember/-internals/glimmer';
   @extends EngineInstance
 */
 
-const ApplicationInstance = EngineInstance.extend({
-  /**
-    The `Application` for which this is an instance.
-     @property {Application} application
-    @private
-  */
-  application: null,
-
-  /**
-    The DOM events for which the event dispatcher should listen.
-     By default, the application's `Ember.EventDispatcher` listens
-    for a set of standard DOM events, such as `mousedown` and
-    `keyup`, and delegates them to your application's `Ember.View`
-    instances.
-     @private
-    @property {Object} customEvents
-  */
-  customEvents: null,
+class ApplicationInstance extends EngineInstance {
+  constructor() {
+    super(...arguments);
+    /**
+      The root DOM element of the Application as an element or a
+      CSS selector.
+             @private
+      @property {String|DOMElement} rootElement
+    */
 
-  /**
-    The root DOM element of the Application as an element or a
-    CSS selector.
-     @private
-    @property {String|DOMElement} rootElement
-  */
-  rootElement: null,
+    this.rootElement = null;
+  }
 
-  init() {
-    this._super(...arguments);
+  init(properties) {
+    super.init(properties);
 
     this.application._watchInstance(this); // Register this instance in the per-instance registry.
     //
@@ -72,25 +61,26 @@ const ApplicationInstance = EngineInstance.extend({
     this.register('-application-instance:main', this, {
       instantiate: false
     });
-  },
-
+  }
   /**
     Overrides the base `EngineInstance._bootSync` method with concerns relevant
     to booting application (instead of engine) instances.
-     This method should only contain synchronous boot concerns. Asynchronous
+       This method should only contain synchronous boot concerns. Asynchronous
     boot concerns should eventually be moved to the `boot` method, which
     returns a promise.
-     Until all boot code has been made asynchronous, we need to continue to
+       Until all boot code has been made asynchronous, we need to continue to
     expose this method for use *internally* in places where we need to boot an
     instance synchronously.
-     @private
+       @private
   */
+
+
   _bootSync(options) {
     if (this._booted) {
       return this;
     }
 
-    options = new BootOptions(options);
+    options = new _BootOptions(options);
     this.setupRegistry(options);
 
     if (options.rootElement) {
@@ -111,93 +101,104 @@ const ApplicationInstance = EngineInstance.extend({
 
     this._booted = true;
     return this;
-  },
+  }
 
   setupRegistry(options) {
     this.constructor.setupRegistry(this.__registry__, options);
-  },
+  }
 
-  router: computed(function () {
-    return this.lookup('router:main');
-  }).readOnly(),
+  get router() {
+    if (!this._router) {
+      let router = this.lookup('router:main');
+      assert('expected an instance of Router', router instanceof Router);
+      this._router = router;
+    }
 
+    return this._router;
+  }
   /**
     This hook is called by the root-most Route (a.k.a. the ApplicationRoute)
     when it has finished creating the root View. By default, we simply take the
     view and append it to the `rootElement` specified on the Application.
-     In cases like FastBoot and testing, we can override this hook and implement
+       In cases like FastBoot and testing, we can override this hook and implement
     custom behavior, such as serializing to a string and sending over an HTTP
     socket rather than appending to DOM.
-     @param view {Ember.View} the root-most view
+       @param view {Ember.View} the root-most view
     @deprecated
     @private
   */
+
+
   didCreateRootView(view) {
     view.appendTo(this.rootElement);
-  },
-
+  }
   /**
     Tells the router to start routing. The router will ask the location for the
     current URL of the page to determine the initial URL to start routing to.
     To start the app at a specific URL, call `handleURL` instead.
-     @private
+       @private
   */
+
+
   startRouting() {
     this.router.startRouting();
-  },
-
+  }
   /**
     Sets up the router, initializing the child router and configuring the
     location before routing begins.
-     Because setup should only occur once, multiple calls to `setupRouter`
+       Because setup should only occur once, multiple calls to `setupRouter`
     beyond the first call have no effect.
-     This is commonly used in order to confirm things that rely on the router
+       This is commonly used in order to confirm things that rely on the router
     are functioning properly from tests that are primarily rendering related.
-     For example, from within [ember-qunit](https://github.com/emberjs/ember-qunit)'s
+       For example, from within [ember-qunit](https://github.com/emberjs/ember-qunit)'s
     `setupRenderingTest` calling `this.owner.setupRouter()` would allow that
     rendering test to confirm that any `<LinkTo></LinkTo>`'s that are rendered
     have the correct URL.
-     @public
+       @public
   */
+
+
   setupRouter() {
     this.router.setupRouter();
-  },
-
+  }
   /**
     Directs the router to route to a particular URL. This is useful in tests,
     for example, to tell the app to start at a particular URL.
-     @param url {String} the URL the router should route to
+       @param url {String} the URL the router should route to
     @private
   */
+
+
   handleURL(url) {
     this.setupRouter();
     return this.router.handleURL(url);
-  },
-
+  }
   /**
     @private
   */
+
+
   setupEventDispatcher() {
     let dispatcher = this.lookup('event_dispatcher:main');
+    assert('expected EventDispatcher', dispatcher instanceof EventDispatcher);
     let applicationCustomEvents = get(this.application, 'customEvents');
     let instanceCustomEvents = get(this, 'customEvents');
     let customEvents = Object.assign({}, applicationCustomEvents, instanceCustomEvents);
     dispatcher.setup(customEvents, this.rootElement);
     return dispatcher;
-  },
-
+  }
   /**
     Returns the current URL of the app instance. This is useful when your
     app does not update the browsers URL bar (i.e. it uses the `'none'`
     location adapter).
-     @public
+       @public
     @return {String} the current URL
   */
+
+
   getURL() {
     return this.router.url;
-  },
-
-  // `instance.visit(url)` should eventually replace `instance.handleURL()`;
+  } // `instance.visit(url)` should eventually replace `instance.handleURL()`;
   // the test helpers can probably be switched to use this implementation too
 
   /**
@@ -205,10 +206,12 @@ const ApplicationInstance = EngineInstance.extend({
     example, or to tell the app to start at a particular URL. This method
     returns a promise that resolves with the app instance when the transition
     is complete, or rejects if the transion was aborted due to an error.
-     @public
+       @public
     @param url {String} the destination URL
     @return {Promise<ApplicationInstance>}
   */
+
+
   visit(url) {
     this.setupRouter();
 
@@ -238,43 +241,39 @@ const ApplicationInstance = EngineInstance.extend({
       }
     };
 
-    let location = get(router, 'location'); // Keeps the location adapter's internal URL in-sync
+    let location = get(router, 'location');
+    assert('location has been initialized', typeof location !== 'string'); // Keeps the location adapter's internal URL in-sync
 
     location.setURL(url); // getURL returns the set url with the rootURL stripped off
 
     return router.handleURL(location.getURL()).then(handleTransitionResolve, handleTransitionReject);
-  },
+  }
 
   willDestroy() {
-    this._super(...arguments);
+    super.willDestroy();
 
     this.application._unwatchInstance(this);
   }
-
-});
-ApplicationInstance.reopenClass({
   /**
    @private
    @method setupRegistry
    @param {Registry} registry
    @param {BootOptions} options
   */
-  setupRegistry(registry, options = {}) {
-    if (!options.toEnvironment) {
-      options = new BootOptions(options);
-    }
 
-    registry.register('-environment:main', options.toEnvironment(), {
+
+  static setupRegistry(registry, options = {}) {
+    let coptions = options instanceof _BootOptions ? options : new _BootOptions(options);
+    registry.register('-environment:main', coptions.toEnvironment(), {
       instantiate: false
     });
-    registry.register('service:-document', options.document, {
+    registry.register('service:-document', coptions.document, {
       instantiate: false
     });
-
-    this._super(registry, options);
+    super.setupRegistry(registry, coptions);
   }
 
-});
+}
 /**
   A list of boot-time configuration options for customizing the behavior of
   an `ApplicationInstance`.
@@ -298,44 +297,22 @@ ApplicationInstance.reopenClass({
   @public
 */
 
-class BootOptions {
-  constructor(options = {}) {
-    /**
-      Interactive mode: whether we need to set up event delegation and invoke
-      lifecycle callbacks on Components.
-       @property isInteractive
-      @type boolean
-      @default auto-detected
-      @private
-    */
-    this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
 
+class _BootOptions {
+  constructor(options = {}) {
     /**
-      @property _renderMode
+      If present, overrides the router's `location` property with this
+      value. This is useful for environments where trying to modify the
+      URL would be inappropriate.
+             @property location
       @type string
-      @default undefined
-      @private
+      @default null
+      @public
     */
+    this.location = null;
+    this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
 
     this._renderMode = options._renderMode;
-    /**
-      Run in a full browser environment.
-       When this flag is set to `false`, it will disable most browser-specific
-      and interactive features. Specifically:
-       * It does not use `jQuery` to append the root view; the `rootElement`
-        (either specified as a subsequent option or on the application itself)
-        must already be an `Element` in the given `document` (as opposed to a
-        string selector).
-       * It does not set up an `EventDispatcher`.
-       * It does not run any `Component` lifecycle hooks (such as `didInsertElement`).
-       * It sets the `location` option to `"none"`. (If you would like to use
-        the location adapter specified in the app's router instead, you can also
-        specify `{ location: null }` to specifically opt-out.)
-       @property isBrowser
-      @type boolean
-      @default auto-detected
-      @public
-    */
 
     if (options.isBrowser !== undefined) {
       this.isBrowser = Boolean(options.isBrowser);
@@ -347,17 +324,6 @@ class BootOptions {
       this.isInteractive = false;
       this.location = 'none';
     }
-    /**
-      Disable rendering completely.
-       When this flag is set to `false`, it will disable the entire rendering
-      pipeline. Essentially, this puts the app into "routing-only" mode. No
-      templates will be rendered, and no Components will be created.
-       @property shouldRender
-      @type boolean
-      @default true
-      @public
-    */
-
 
     if (options.shouldRender !== undefined) {
       this.shouldRender = Boolean(options.shouldRender);
@@ -368,46 +334,12 @@ class BootOptions {
     if (!this.shouldRender) {
       this.isInteractive = false;
     }
-    /**
-      If present, render into the given `Document` object instead of the
-      global `window.document` object.
-       In practice, this is only useful in non-browser environment or in
-      non-interactive mode, because Ember's `jQuery` dependency is
-      implicitly bound to the current document, causing event delegation
-      to not work properly when the app is rendered into a foreign
-      document object (such as an iframe's `contentDocument`).
-       In non-browser mode, this could be a "`Document`-like" object as
-      Ember only interact with a small subset of the DOM API in non-
-      interactive mode. While the exact requirements have not yet been
-      formalized, the `SimpleDOM` library's implementation is known to
-      work.
-       @property document
-      @type Document
-      @default the global `document` object
-      @public
-    */
-
 
     if (options.document) {
       this.document = options.document;
     } else {
       this.document = typeof document !== 'undefined' ? document : null;
     }
-    /**
-      If present, overrides the application's `rootElement` property on
-      the instance. This is useful for testing environment, where you
-      might want to append the root view to a fixture area.
-       In non-browser mode, because Ember does not have access to jQuery,
-      this options must be specified as a DOM `Element` object instead of
-      a selector string.
-       See the documentation on `Application`'s `rootElement` for
-      details.
-       @property rootElement
-      @type String|Element
-      @default null
-      @public
-     */
-
 
     if (options.rootElement) {
       this.rootElement = options.rootElement;
@@ -415,16 +347,6 @@ class BootOptions {
     // defaults from the "combo" options like `isBrowser` (although in
     // practice, the resulting combination is probably invalid)
 
-    /**
-      If present, overrides the router's `location` property with this
-      value. This is useful for environments where trying to modify the
-      URL would be inappropriate.
-       @property location
-      @type string
-      @default null
-      @public
-    */
-
 
     if (options.location !== undefined) {
       this.location = options.location;
@@ -437,13 +359,13 @@ class BootOptions {
 
   toEnvironment() {
     // Do we really want to assign all of this!?
-    let env = Object.assign({}, environment); // For compatibility with existing code
-
-    env.hasDOM = this.isBrowser;
-    env.isInteractive = this.isInteractive;
-    env._renderMode = this._renderMode;
-    env.options = this;
-    return env;
+    return Object.assign(Object.assign({}, environment), {
+      // For compatibility with existing code
+      hasDOM: this.isBrowser,
+      isInteractive: this.isInteractive,
+      _renderMode: this._renderMode,
+      options: this
+    });
   }
 
 }