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

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

@@ -26,151 +26,6 @@ function cleanURL(url, rootURL) {
 }
 
 class RouterService extends Service.extend(Evented) {
-  constructor() {
-    super(...arguments);
-    /**
-      You can register a listener for events emitted by this service with `.on()`:
-             ```app/routes/contact-form.js
-      import Route from '@ember/routing';
-      import { service } from '@ember/service';
-             export default class extends Route {
-        @service router;
-               activate() {
-          this.router.on('routeWillChange', (transition) => {
-            if (!transition.to.find(route => route.name === this.routeName)) {
-              alert("Please save or cancel your changes.");
-              transition.abort();
-            }
-          })
-        }
-      }
-      ```
-             @method on
-      @param {String} eventName
-      @param {Function} callback
-      @public
-    */
-
-    /**
-      You can unregister a listener for events emitted by this service with `.off()`:
-             ```app/routes/contact-form.js
-      import Route from '@ember/routing';
-      import { service } from '@ember/service';
-             export default class extends Route {
-        @service router;
-               callback = (transition) =>  {
-          if (!transition.to.find(route => route.name === this.routeName)) {
-            alert("Please save or cancel your changes.");
-            transition.abort();
-          }
-        };
-               activate() {
-          this.router.on('routeWillChange', this.callback);
-        }
-               deactivate() {
-          this.router.off('routeWillChange', this.callback);
-      }
-      ```
-             @method off
-      @param {String} eventName
-      @param {Function} callback
-      @public
-    */
-
-    /**
-      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;
-               activate() {
-          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
-    */
-
-    /**
-      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;
-               activate() {
-          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
-
-    /**
-     * 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
-     */
-
-    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;
-  }
-
   get _router() {
     let router = this[ROUTER];
 
@@ -494,6 +349,146 @@ class RouterService extends Service.extend(Evented) {
     let internalURL = cleanURL(url, this.rootURL);
     return this._router._routerMicrolib.recognizeAndLoad(internalURL);
   }
+  /**
+    You can register a listener for events emitted by this service with `.on()`:
+       ```app/routes/contact-form.js
+    import Route from '@ember/routing';
+    import { service } from '@ember/service';
+       export default class extends Route {
+      @service router;
+         activate() {
+        this.router.on('routeWillChange', (transition) => {
+          if (!transition.to.find(route => route.name === this.routeName)) {
+            alert("Please save or cancel your changes.");
+            transition.abort();
+          }
+        })
+      }
+    }
+    ```
+       @method on
+    @param {String} eventName
+    @param {Function} callback
+    @public
+  */
+
+  /**
+    You can unregister a listener for events emitted by this service with `.off()`:
+       ```app/routes/contact-form.js
+    import Route from '@ember/routing';
+    import { service } from '@ember/service';
+       export default class extends Route {
+      @service router;
+         callback = (transition) =>  {
+        if (!transition.to.find(route => route.name === this.routeName)) {
+          alert("Please save or cancel your changes.");
+          transition.abort();
+        }
+      };
+         activate() {
+        this.router.on('routeWillChange', this.callback);
+      }
+         deactivate() {
+        this.router.off('routeWillChange', this.callback);
+    }
+    ```
+       @method off
+    @param {String} eventName
+    @param {Function} callback
+    @public
+  */
+
+  /**
+    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;
+         activate() {
+        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
+  */
+
+  /**
+    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;
+         activate() {
+        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
+  */
+
+  /**
+   * 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
+   * @public
+   */
+
+
+  refresh(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}`); // R could be instantiated with a different sub-type
+    // @ts-ignore
+
+    return this._router._routerMicrolib.refresh(pivotRoute);
+  }
 
 }
 

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

@@ -1,4 +1,8 @@
 export {};
+/**
+ @module @ember/routing
+*/
+
 /**
   A `RouteInfoWithAttributes` is an object that contains
   metadata, including the resolved value from the routes

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

@@ -225,6 +225,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
         seen[name] = true;
 
         if (!route) {
+          // SAFETY: this is configured in `commonSetupRegistry` in the
+          // `@ember/application/lib` package.
           let DefaultRoute = routeOwner.factoryFor('route:basic').class;
           routeOwner.register(fullRouteName, DefaultRoute.extend());
           route = routeOwner.lookup(fullRouteName);

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

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ @module @ember/routing
+*/
+
 /**
   A Transition is a thennable (a promise-like object) that represents
   an attempt to transition to another route. It can be aborted, either