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

package/dist/packages/@ember/-internals/routing/lib/services/router.js

@@ -1,3 +1,11 @@
+var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
 import { getOwner } from '@ember/-internals/owner';
 import { Evented } from '@ember/-internals/runtime';
 import { symbol } from '@ember/-internals/utils';
@@ -15,40 +23,106 @@ function cleanURL(url, rootURL) {
 
   return url.substr(rootURL.length, url.length);
 }
-/**
-   The Router service is the public API that provides access to the router.
-
-   The immediate benefit of the Router service is that you can inject it into components,
-   giving them a friendly way to initiate transitions and ask questions about the current
-   global router state.
-
-   In this example, the Router service is injected into a component to initiate a transition
-   to a dedicated route:
-
-   ```app/components/example.js
-   import Component from '@glimmer/component';
-   import { action } from '@ember/object';
-   import { service } from '@ember/service';
 
-   export default class ExampleComponent extends Component {
-     @service router;
+class RouterService extends Service.extend(Evented) {
+  constructor() {
+    super(...arguments);
+    /**
+      The `routeWillChange` event is fired at the beginning of any
+      attempted transition with a `Transition` object as the sole
+      argument. This action can be used for aborting, redirecting,
+      or decorating the transition from the currently active routes.
+             A good example is preventing navigation when a form is
+      half-filled out:
+             ```app/routes/contact-form.js
+      import Route from '@ember/routing';
+      import { service } from '@ember/service';
+             export default class extends Route {
+        @service router;
+               constructor() {
+          super(...arguments);
+                 this.router.on('routeWillChange', (transition) => {
+            if (!transition.to.find(route => route.name === this.routeName)) {
+              alert("Please save or cancel your changes.");
+              transition.abort();
+            }
+          })
+        }
+      }
+      ```
+             The `routeWillChange` event fires whenever a new route is chosen as the desired target of a transition. This includes `transitionTo`, `replaceWith`, all redirection for any reason including error handling, and abort. Aborting implies changing the desired target back to where you already were. Once a transition has completed, `routeDidChange` fires.
+             @event routeWillChange
+      @param {Transition} transition
+      @public
+    */
 
-     @action
-     next() {
-       this.router.transitionTo('other.route');
-     }
-   }
-   ```
+    /**
+      The `routeDidChange` event only fires once a transition has settled.
+      This includes aborts and error substates. Like the `routeWillChange` event
+      it receives a Transition as the sole argument.
+             A good example is sending some analytics when the route has transitioned:
+             ```app/routes/contact-form.js
+      import Route from '@ember/routing';
+      import { service } from '@ember/service';
+             export default class extends Route {
+        @service router;
+               constructor() {
+          super(...arguments);
+                 this.router.on('routeDidChange', (transition) => {
+            ga.send('pageView', {
+              current: transition.to.name,
+              from: transition.from.name
+            });
+          })
+        }
+      }
+      ```
+             `routeDidChange` will be called after any `Route`'s
+      [didTransition](/ember/release/classes/Route/events/didTransition?anchor=didTransition)
+      action has been fired.
+      The updates of properties
+      [currentURL](/ember/release/classes/RouterService/properties/currentURL?anchor=currentURL),
+      [currentRouteName](/ember/release/classes/RouterService/properties/currentURL?anchor=currentRouteName)
+      and
+      [currentRoute](/ember/release/classes/RouterService/properties/currentURL?anchor=currentRoute)
+      are completed at the time `routeDidChange` is called.
+             @event routeDidChange
+      @param {Transition} transition
+      @public
+    */
+    // Canary features
 
-   Like any service, it can also be injected into helpers, routes, etc.
+    /**
+     * Refreshes all currently active routes, doing a full transition.
+     * If a route name is provided and refers to a currently active route,
+     * it will refresh only that route and its descendents.
+     * Returns a promise that will be resolved once the refresh is complete.
+     * All resetController, beforeModel, model, afterModel, redirect, and setupController
+     * hooks will be called again. You will get new data from the model hook.
+     *
+     * @method refresh
+     * @param {String} [routeName] the route to refresh (along with all child routes)
+     * @return Transition
+     * @category EMBER_ROUTING_ROUTER_SERVICE_REFRESH
+     * @public
+     */
 
-   @public
-   @extends Service
-   @class RouterService
- */
+    this.refresh = true
+    /* EMBER_ROUTING_ROUTER_SERVICE_REFRESH */
+    ? function (pivotRouteName) {
+      if (!pivotRouteName) {
+        return this._router._routerMicrolib.refresh();
+      }
 
+      assert(`The route "${pivotRouteName}" was not found`, this._router.hasRoute(pivotRouteName));
+      assert(`The route "${pivotRouteName}" is currently not active`, this.isActive(pivotRouteName));
+      let owner = getOwner(this);
+      assert('RouterService is unexpectedly missing an owner', owner);
+      let pivotRoute = owner.lookup(`route:${pivotRouteName}`);
+      return this._router._routerMicrolib.refresh(pivotRoute);
+    } : undefined;
+  }
 
-export default class RouterService extends Service {
   get _router() {
     let router = this[ROUTER];
 
@@ -56,15 +130,55 @@ export default class RouterService extends Service {
       return router;
     }
 
-    const owner = getOwner(this);
+    let owner = getOwner(this);
+    assert('RouterService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
     return this[ROUTER] = router;
   }
 
   willDestroy() {
-    super.willDestroy(...arguments);
+    super.willDestroy();
     this[ROUTER] = null;
   }
+  /**
+     Transition the application into another route. The route may
+     be either a single route or route path:
+        Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
+     This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
+     See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
+        In the following example we use the Router service to navigate to a route with a
+     specific model from a Component in the first action, and in the second we trigger
+     a query-params only transition.
+        ```app/components/example.js
+     import Component from '@glimmer/component';
+     import { action } from '@ember/object';
+     import { service } from '@ember/service';
+        export default class extends Component {
+       @service router;
+          @action
+       goToComments(post) {
+         this.router.transitionTo('comments', post);
+       }
+          @action
+       fetchMoreComments(latestComment) {
+         this.router.transitionTo({
+           queryParams: { commentsAfter: latestComment }
+         });
+       }
+     }
+     ```
+        @method transitionTo
+     @param {String} [routeNameOrUrl] the name of the route or a URL
+     @param {...Object} [models] the model(s) or identifier(s) to be used while
+       transitioning to the route.
+     @param {Object} [options] optional hash with a queryParams property
+       containing a mapping of query parameters. May be supplied as the only
+      parameter to trigger a query-parameter-only transition.
+     @return {Transition} the transition object associated with this
+       attempted transition
+     @public
+   */
+
 
   transitionTo(...args) {
     if (resemblesURL(args[0])) {
@@ -90,7 +204,6 @@ export default class RouterService extends Service {
      When the user clicks the "back" button in the browser, there will be fewer steps.
      This is most commonly used to manage redirects in a way that does not cause confusing additions
      to the user's browsing history.
-        See [replaceWith](/ember/release/classes/Route/methods/replaceWith?anchor=replaceWith) for more info.
         Calling `replaceWith` from the Router service will cause default query parameter values to be included in the URL.
      This behavior is different from calling `replaceWith` on a route.
      See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
@@ -117,8 +230,8 @@ export default class RouterService extends Service {
    */
 
 
-  replaceWith() {
-    return this.transitionTo(...arguments).method('replace');
+  replaceWith(...args) {
+    return this.transitionTo(...args).method('replace');
   }
   /**
     Generate a URL based on the supplied route name and optionally a model. The
@@ -171,8 +284,7 @@ export default class RouterService extends Service {
     ```
         @method urlFor
      @param {String} routeName the name of the route
-     @param {...Object} models the model(s) or identifier(s) to be used while
-       transitioning to the route.
+     @param {...Object} models the model(s) for the route.
      @param {Object} [options] optional hash with a queryParams property
        containing a mapping of query parameters
      @return {String} the string representing the generated URL
@@ -293,6 +405,7 @@ export default class RouterService extends Service {
      ```
          @method recognize
       @param {String} url
+      @return {RouteInfo | null}
       @public
     */
 
@@ -313,6 +426,7 @@ export default class RouterService extends Service {
     the browser including the app's `rootURL`.
          @method recognizeAndLoad
       @param {String} url
+      @return {RouteInfo}
       @public
    */
 
@@ -328,163 +442,14 @@ export default class RouterService extends Service {
 
 }
 
-if (true
-/* EMBER_ROUTING_ROUTER_SERVICE_REFRESH */
-) {
-  RouterService.reopen({
-    /**
-     * Refreshes all currently active routes, doing a full transition.
-     * If a route name is provided and refers to a currently active route,
-     * it will refresh only that route and its descendents.
-     * Returns a promise that will be resolved once the refresh is complete.
-     * All resetController, beforeModel, model, afterModel, redirect, and setupController
-     * hooks will be called again. You will get new data from the model hook.
-     *
-     * @method refresh
-     * @param {String} [routeName] the route to refresh (along with all child routes)
-     * @return Transition
-     * @category EMBER_ROUTING_ROUTER_SERVICE_REFRESH
-     * @public
-     */
-    refresh(pivotRouteName) {
-      if (!pivotRouteName) {
-        return this._router._routerMicrolib.refresh();
-      }
+__decorate([readOnly('_router.currentRouteName')], RouterService.prototype, "currentRouteName", void 0);
 
-      assert(`The route "${pivotRouteName}" was not found`, this._router.hasRoute(pivotRouteName));
-      assert(`The route "${pivotRouteName}" is currently not active`, this.isActive(pivotRouteName));
-      let pivotRoute = getOwner(this).lookup(`route:${pivotRouteName}`);
-      return this._router._routerMicrolib.refresh(pivotRoute);
-    }
+__decorate([readOnly('_router.currentURL')], RouterService.prototype, "currentURL", void 0);
 
-  });
-}
-
-RouterService.reopen(Evented, {
-  /**
-     Name of the current route.
-        This property represents the logical name of the route,
-     which is comma separated.
-     For the following router:
-        ```app/router.js
-     Router.map(function() {
-       this.route('about');
-       this.route('blog', function () {
-         this.route('post', { path: ':post_id' });
-       });
-     });
-     ```
-        It will return:
-        * `index` when you visit `/`
-     * `about` when you visit `/about`
-     * `blog.index` when you visit `/blog`
-     * `blog.post` when you visit `/blog/some-post-id`
-        @property currentRouteName
-     @type String
-     @public
-   */
-  currentRouteName: readOnly('_router.currentRouteName'),
-
-  /**
-     Current URL for the application.
-       This property represents the URL path for this route.
-    For the following router:
-        ```app/router.js
-     Router.map(function() {
-       this.route('about');
-       this.route('blog', function () {
-         this.route('post', { path: ':post_id' });
-       });
-     });
-     ```
-        It will return:
-        * `/` when you visit `/`
-     * `/about` when you visit `/about`
-     * `/blog` when you visit `/blog`
-     * `/blog/some-post-id` when you visit `/blog/some-post-id`
-        @property currentURL
-     @type String
-     @public
-   */
-  currentURL: readOnly('_router.currentURL'),
+__decorate([readOnly('_router.location')], RouterService.prototype, "location", void 0);
 
-  /**
-    The `location` property returns what implementation of the `location` API
-    your application is using, which determines what type of URL is being used.
-       See [Location](/ember/release/classes/Location) for more information.
-       To force a particular `location` API implementation to be used in your
-    application you can set a location type on your `config/environment`.
-    For example, to set the `history` type:
-       ```config/environment.js
-    'use strict';
-       module.exports = function(environment) {
-      let ENV = {
-        modulePrefix: 'router-service',
-        environment,
-        rootURL: '/',
-        locationType: 'history',
-        ...
-      }
-    }
-    ```
-       The following location types are available by default:
-    `auto`, `hash`, `history`, `none`.
-       See [HashLocation](/ember/release/classes/HashLocation).
-    See [HistoryLocation](/ember/release/classes/HistoryLocation).
-    See [NoneLocation](/ember/release/classes/NoneLocation).
-    See [AutoLocation](/ember/release/classes/AutoLocation).
-       @property location
-    @default 'hash'
-    @see {Location}
-    @public
-  */
-  location: readOnly('_router.location'),
+__decorate([readOnly('_router.rootURL')], RouterService.prototype, "rootURL", void 0);
 
-  /**
-    The `rootURL` property represents the URL of the root of
-    the application, '/' by default.
-    This prefix is assumed on all routes defined on this app.
-       If you change the `rootURL` in your environment configuration
-    like so:
-       ```config/environment.js
-    'use strict';
-       module.exports = function(environment) {
-      let ENV = {
-        modulePrefix: 'router-service',
-        environment,
-        rootURL: '/my-root',
-      …
-      }
-    ]
-    ```
-       This property will return `/my-root`.
-       @property rootURL
-    @default '/'
-    @public
-  */
-  rootURL: readOnly('_router.rootURL'),
+__decorate([readOnly('_router.currentRoute')], RouterService.prototype, "currentRoute", void 0);
 
-  /**
-    The `currentRoute` property contains metadata about the current leaf route.
-    It returns a `RouteInfo` object that has information like the route name,
-    params, query params and more.
-       See [RouteInfo](/ember/release/classes/RouteInfo) for more info.
-       This property is guaranteed to change whenever a route transition
-    happens (even when that transition only changes parameters
-    and doesn't change the active route).
-       Usage example:
-    ```app/components/header.js
-      import Component from '@glimmer/component';
-      import { service } from '@ember/service';
-      import { notEmpty } from '@ember/object/computed';
-         export default class extends Component {
-        @service router;
-           @notEmpty('router.currentRoute.child') isChildRoute;
-      });
-    ```
-        @property currentRoute
-     @type RouteInfo
-     @public
-   */
-  currentRoute: readOnly('_router.currentRoute')
-});
+export { RouterService as default };

package/dist/packages/@ember/-internals/routing/lib/services/routing.js

@@ -3,6 +3,7 @@
 */
 import { getOwner } from '@ember/-internals/owner';
 import { symbol } from '@ember/-internals/utils';
+import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 const ROUTER = symbol('ROUTER');
@@ -25,7 +26,8 @@ export default class RoutingService extends Service {
       return router;
     }
 
-    const owner = getOwner(this);
+    let owner = getOwner(this);
+    assert('RoutingService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
     router.setupRouter();
     return this[ROUTER] = router;

package/dist/packages/@ember/-internals/routing/lib/system/route-info.js

@@ -1,4 +1,4 @@
-"use strict";
+export {};
 /**
   A `RouteInfoWithAttributes` is an object that contains
   metadata, including the resolved value from the routes
@@ -55,7 +55,7 @@
 /**
   This is the resolved return value from the
   route's model hook.
-  @property {Object|Array|String} attributes
+  @property {Object|Array|String|undefined} attributes
   @public
 */