ember-source 4.3.0-alpha.1 → 4.3.0-beta.1

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

@@ -20,47 +20,6 @@ import { calculateCacheKey, deprecateTransitionMethods, normalizeControllerQuery
 import generateController from './generate_controller';
 export const ROUTE_CONNECTIONS = new WeakMap();
 const RENDER = symbol('render');
-export function defaultSerialize(model, params) {
-  if (params.length < 1 || !model) {
-    return;
-  }
-
-  let object = {};
-
-  if (params.length === 1) {
-    let [name] = params;
-
-    if (name in model) {
-      object[name] = get(model, name);
-    } else if (/_id$/.test(name)) {
-      object[name] = get(model, 'id');
-    } else if (isProxy(model)) {
-      object[name] = get(model, name);
-    }
-  } else {
-    object = getProperties(model, params);
-  }
-
-  return object;
-}
-export function hasDefaultSerialize(route) {
-  return route.serialize === defaultSerialize;
-}
-/**
-@module @ember/routing
-*/
-
-/**
-  The `Route` class is used to define individual routes. Refer to
-  the [routing guide](https://guides.emberjs.com/release/routing/) for documentation.
-
-  @class Route
-  @extends EmberObject
-  @uses ActionHandler
-  @uses Evented
-  @since 1.0.0
-  @public
-*/
 
 class Route extends EmberObject.extend(ActionHandler, Evented) {
   constructor(owner) {
@@ -77,6 +36,68 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       this._environment = owner.lookup('-environment:main');
     }
   }
+  /**
+    A hook you can implement to convert the route's model into parameters
+    for the URL.
+       ```app/router.js
+    // ...
+       Router.map(function() {
+      this.route('post', { path: '/posts/:post_id' });
+    });
+       ```
+       ```app/routes/post.js
+    import Route from '@ember/routing/route';
+       export default class PostRoute extends Route {
+      model({ post_id }) {
+        // the server returns `{ id: 12 }`
+        return fetch(`/posts/${post_id}`;
+      }
+         serialize(model) {
+        // this will make the URL `/posts/12`
+        return { post_id: model.id };
+      }
+    }
+    ```
+       The default `serialize` method will insert the model's `id` into the
+    route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
+    If the route has multiple dynamic segments or does not contain '_id', `serialize`
+    will return `getProperties(model, params)`
+       This method is called when `transitionTo` is called with a context
+    in order to populate the URL.
+       @method serialize
+    @param {Object} model the routes model
+    @param {Array} params an Array of parameter names for the current
+      route (in the example, `['post_id']`.
+    @return {Object} the serialized parameters
+    @since 1.0.0
+    @public
+  */
+
+
+  serialize(model, params) {
+    if (params.length < 1 || !model) {
+      return;
+    }
+
+    let object = {};
+
+    if (params.length === 1) {
+      let [name] = params;
+      assert('has name', name);
+
+      if (name in model) {
+        object[name] = get(model, name);
+      } else if (/_id$/.test(name)) {
+        object[name] = get(model, 'id');
+      } else if (isProxy(model)) {
+        object[name] = get(model, name);
+      }
+    } else {
+      object = getProperties(model, params);
+    }
+
+    return object;
+  }
   /**
     Sets the name for this route, including a fully resolved name for routes
     inside engines.
@@ -88,7 +109,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
   _setRouteName(name) {
     this.routeName = name;
-    this.fullRouteName = getEngineRouteName(getOwner(this), name);
+    let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
+    this.fullRouteName = getEngineRouteName(owner, name);
   }
   /**
     @private
@@ -106,18 +129,17 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     if (!names.length) {
       routeInfo = dynamicParent;
       names = routeInfo && routeInfo['_names'] || [];
-    }
+    } // SAFETY: Since `_qp` is protected we can't infer the type
+
 
-    let qps = get(this, '_qp.qps');
+    let qps = get(this, '_qp').qps;
     let namePaths = new Array(names.length);
 
     for (let a = 0; a < names.length; ++a) {
       namePaths[a] = `${routeInfo.name}.${names[a]}`;
     }
 
-    for (let i = 0; i < qps.length; ++i) {
-      let qp = qps[i];
-
+    for (let qp of qps) {
       if (qp.scope === 'model') {
         qp.parts = namePaths;
       }
@@ -187,7 +209,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   paramsFor(name) {
-    let route = getOwner(this).lookup(`route:${name}`);
+    let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
+    let route = owner.lookup(`route:${name}`);
 
     if (route === undefined) {
       return {};
@@ -198,9 +222,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     let fullName = route.fullRouteName;
     let params = Object.assign({}, state.params[fullName]);
     let queryParams = getQueryParamsFor(route, state);
-    return Object.keys(queryParams).reduce((params, key) => {
+    return Object.entries(queryParams).reduce((params, [key, value]) => {
       assert(`The route '${this.routeName}' has both a dynamic segment and query param with name '${key}'. Please rename one to avoid collisions.`, !params[key]);
-      params[key] = queryParams[key];
+      params[key] = value;
       return params;
     }, params);
   }
@@ -301,8 +325,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   _internalReset(isExiting, transition) {
-    let controller = this.controller;
-    controller['_qpDelegate'] = get(this, '_qp.states.inactive');
+    let controller = this.controller; // SAFETY: Since `_qp` is protected we can't infer the type
+
+    controller['_qpDelegate'] = get(this, '_qp').states.inactive;
     this.resetController(controller, isExiting, transition);
   }
   /**
@@ -316,148 +341,6 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     this.activate(transition);
     this.trigger('activate', transition);
   }
-  /**
-    The `willTransition` action 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/route';
-    import { action } from '@ember/object';
-       export default class ContactFormRoute extends Route {
-      @action
-      willTransition(transition) {
-        if (this.controller.get('userHasEnteredData')) {
-          this.controller.displayNavigationConfirm();
-          transition.abort();
-        }
-      }
-    }
-    ```
-       You can also redirect elsewhere by calling
-    `this.transitionTo('elsewhere')` from within `willTransition`.
-    Note that `willTransition` will not be fired for the
-    redirecting `transitionTo`, since `willTransition` doesn't
-    fire when there is already a transition underway. If you want
-    subsequent `willTransition` actions to fire for the redirecting
-    transition, you must first explicitly call
-    `transition.abort()`.
-       To allow the `willTransition` event to continue bubbling to the parent
-    route, use `return true;`. When the `willTransition` method has a
-    return value of `true` then the parent route's `willTransition` method
-    will be fired, enabling "bubbling" behavior for the event.
-       @event willTransition
-    @param {Transition} transition
-    @since 1.0.0
-    @public
-  */
-
-  /**
-    The `didTransition` action is fired after a transition has
-    successfully been completed. This occurs after the normal model
-    hooks (`beforeModel`, `model`, `afterModel`, `setupController`)
-    have resolved. The `didTransition` action has no arguments,
-    however, it can be useful for tracking page views or resetting
-    state on the controller.
-       ```app/routes/login.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class LoginRoute extends Route {
-      @action
-      didTransition() {
-        this.controller.get('errors.base').clear();
-        return true; // Bubble the didTransition event
-      }
-    }
-    ```
-       @event didTransition
-    @since 1.2.0
-    @public
-  */
-
-  /**
-    The `loading` action is fired on the route when a route's `model`
-    hook returns a promise that is not already resolved. The current
-    `Transition` object is the first parameter and the route that
-    triggered the loading event is the second parameter.
-       ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class ApplicationRoute extends Route {
-      @action
-      loading(transition, route) {
-        let controller = this.controllerFor('foo');
-           // The controller may not be instantiated when initially loading
-        if (controller) {
-          controller.currentlyLoading = true;
-             transition.finally(function() {
-            controller.currentlyLoading = false;
-          });
-        }
-      }
-    }
-    ```
-       @event loading
-    @param {Transition} transition
-    @param {Route} route The route that triggered the loading event
-    @since 1.2.0
-    @public
-  */
-
-  /**
-    When attempting to transition into a route, any of the hooks
-    may return a promise that rejects, at which point an `error`
-    action will be fired on the partially-entered routes, allowing
-    for per-route error handling logic, or shared error handling
-    logic defined on a parent route.
-       Here is an example of an error handler that will be invoked
-    for rejected promises from the various hooks on the route,
-    as well as any unhandled errors from child routes:
-       ```app/routes/admin.js
-    import { reject } from 'rsvp';
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class AdminRoute extends Route {
-      beforeModel() {
-        return reject('bad things!');
-      }
-         @action
-      error(error, transition) {
-        // Assuming we got here due to the error in `beforeModel`,
-        // we can expect that error === "bad things!",
-        // but a promise model rejecting would also
-        // call this hook, as would any errors encountered
-        // in `afterModel`.
-           // The `error` hook is also provided the failed
-        // `transition`, which can be stored and later
-        // `.retry()`d if desired.
-           this.transitionTo('login');
-      }
-    }
-    ```
-       `error` actions that bubble up all the way to `ApplicationRoute`
-    will fire a default error handler that logs the error. You can
-    specify your own global default error handler by overriding the
-    `error` handler on `ApplicationRoute`:
-       ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class ApplicationRoute extends Route {
-      @action
-      error(error, transition) {
-        this.controllerFor('banner').displayError(error.message);
-      }
-    }
-    ```
-    @event error
-    @param {Error} error
-    @param {Transition} transition
-    @since 1.0.0
-    @public
-  */
-
   /**
     This event is triggered when the router enters the route. It is
     not executed when the model for the route changes.
@@ -768,24 +651,17 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   setup(context, transition) {
     let controllerName = this.controllerName || this.routeName;
     let definedController = this.controllerFor(controllerName, true);
-    let controller;
+    let controller = definedController !== null && definedController !== void 0 ? definedController : this.generateController(controllerName); // SAFETY: Since `_qp` is protected we can't infer the type
 
-    if (definedController) {
-      controller = definedController;
-    } else {
-      controller = this.generateController(controllerName);
-    } // Assign the route's controller so that it can more easily be
+    let queryParams = get(this, '_qp'); // Assign the route's controller so that it can more easily be
     // referenced in action handlers. Side effects. Side effects everywhere.
 
-
     if (!this.controller) {
-      let qp = get(this, '_qp');
-      let propNames = qp !== undefined ? get(qp, 'propertyNames') : [];
+      let propNames = queryParams.propertyNames;
       addQueryParamsObservers(controller, propNames);
       this.controller = controller;
     }
 
-    let queryParams = get(this, '_qp');
     let states = queryParams.states;
     controller._qpDelegate = states.allowOverrides;
 
@@ -797,6 +673,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       let allParams = queryParams.propertyNames;
       allParams.forEach(prop => {
         let aQp = queryParams.map[prop];
+        assert('expected aQp', aQp);
         aQp.values = params;
         let cacheKey = calculateCacheKey(aQp.route.fullRouteName, aQp.parts, aQp.values);
         let value = cache.lookup(cacheKey, prop, aQp.undecoratedDefaultValue);
@@ -833,71 +710,10 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     let cacheKey = calculateCacheKey(qp.route.fullRouteName, qp.parts, qp.values);
     cache.stash(cacheKey, prop, value);
   }
-  /**
-    This hook is the first of the route entry validation hooks
-    called when an attempt is made to transition into a route
-    or one of its children. It is called before `model` and
-    `afterModel`, and is appropriate for cases when:
-       1) A decision can be made to redirect elsewhere without
-       needing to resolve the model first.
-    2) Any async operations need to occur first before the
-       model is attempted to be resolved.
-       This hook is provided the current `transition` attempt
-    as a parameter, which can be used to `.abort()` the transition,
-    save it for a later `.retry()`, or retrieve values set
-    on it from a previous hook. You can also just call
-    `this.transitionTo` to another route to implicitly
-    abort the `transition`.
-       You can return a promise from this hook to pause the
-    transition until the promise resolves (or rejects). This could
-    be useful, for instance, for retrieving async code from
-    the server that is required to enter a route.
-       @method beforeModel
-    @param {Transition} transition
-    @return {any | Promise<any>} if the value returned from this hook is
-      a promise, the transition will pause until the transition
-      resolves. Otherwise, non-promise return values are not
-      utilized in any way.
-    @since 1.0.0
-    @public
-  */
-
-
-  beforeModel() {}
-  /**
-    This hook is called after this route's model has resolved.
-    It follows identical async/promise semantics to `beforeModel`
-    but is provided the route's resolved model in addition to
-    the `transition`, and is therefore suited to performing
-    logic that can only take place after the model has already
-    resolved.
-       ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-       export default class PostsRoute extends Route {
-      afterModel(posts, transition) {
-        if (posts.get('length') === 1) {
-          this.transitionTo('post.show', posts.get('firstObject'));
-        }
-      }
-    }
-    ```
-       Refer to documentation for `beforeModel` for a description
-    of transition-pausing semantics when a promise is returned
-    from this hook.
-       @method afterModel
-    @param {Object} resolvedModel the value returned from `model`,
-      or its resolved value if it was a promise
-    @param {Transition} transition
-    @return {any | Promise<any>} if the value returned from this hook is
-      a promise, the transition will pause until the transition
-      resolves. Otherwise, non-promise return values are not
-      utilized in any way.
-    @since 1.0.0
-    @public
-   */
 
+  beforeModel(_transition) {}
 
-  afterModel() {}
+  afterModel(_resolvedModel, _transition) {}
   /**
     A hook you can implement to optionally redirect to another route.
        Calling `this.transitionTo` from inside of the `redirect` hook will
@@ -920,7 +736,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   */
 
 
-  redirect() {}
+  redirect(_model, _transition) {}
   /**
     Called when the context is changed by router.js.
        @private
@@ -994,8 +810,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   model(params, transition) {
-    let name, sawParams, value;
-    let queryParams = get(this, '_qp.map');
+    let name, sawParams, value; // SAFETY: Since `_qp` is protected we can't infer the type
+
+    let queryParams = get(this, '_qp').map;
 
     for (let prop in params) {
       if (prop === 'queryParams' || queryParams && prop in queryParams) {
@@ -1014,11 +831,14 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
     if (!name) {
       if (sawParams) {
+        // SAFETY: This should be equivalent
         return Object.assign({}, params);
       } else {
         if (transition.resolveIndex < 1) {
           return;
-        }
+        } // SAFETY: These return types should be equivalent but router.js doesn't have enough
+        // generics to infer it.
+
 
         return transition[STATE_SYMBOL].routeInfos[transition.resolveIndex - 1].context;
       }
@@ -1105,35 +925,14 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   setupController(controller, context, _transition) {
-    // eslint-disable-line no-unused-vars
     if (controller && context !== undefined) {
       set(controller, 'model', context);
     }
   }
-  /**
-    Returns the controller of the current route, or a parent (or any ancestor)
-    route in a route hierarchy.
-       The controller instance must already have been created, either through entering the
-    associated route or using `generateController`.
-       ```app/routes/post.js
-    import Route from '@ember/routing/route';
-       export default class PostRoute extends Route {
-      setupController(controller, post) {
-        super.setupController(controller, post);
-           this.controllerFor('posts').set('currentPost', post);
-      }
-    }
-    ```
-       @method controllerFor
-    @param {String} name the name of the route or controller
-    @return {Controller}
-    @since 1.0.0
-    @public
-  */
 
-
-  controllerFor(name, _skipAssert) {
+  controllerFor(name, _skipAssert = false) {
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let route = owner.lookup(`route:${name}`);
 
     if (route && route.controllerName) {
@@ -1167,6 +966,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
   generateController(name) {
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     return generateController(owner, name);
   }
   /**
@@ -1208,6 +1008,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   modelFor(_name) {
     let name;
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let transition = this._router && this._router._routerMicrolib ? this._router._routerMicrolib.activeTransition : undefined; // Only change the route name when there is an active transition.
     // Otherwise, use the passed in route name.
 
@@ -1228,7 +1029,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       }
     }
 
-    return route && route.currentModel;
+    return route === null || route === void 0 ? void 0 : route.currentModel;
   }
   /**
     `this[RENDER]` is used to render a template into a region of another template
@@ -1271,39 +1072,6 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       once(this._router, '_setOutlets');
     }
   }
-  /**
-    Allows you to produce custom metadata for the route.
-    The return value of this method will be attached to
-    its corresponding RouteInfoWithAttributes object.
-       Example
-       ```app/routes/posts/index.js
-    import Route from '@ember/routing/route';
-       export default class PostsIndexRoute extends Route {
-      buildRouteInfoMetadata() {
-        return { title: 'Posts Page' }
-      }
-    }
-    ```
-       ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { service } from '@ember/service';
-       export default class ApplicationRoute extends Route {
-      @service router
-         constructor() {
-        super(...arguments);
-           this.router.on('routeDidChange', transition => {
-          document.title = transition.to.metadata.title;
-          // would update document's title to "Posts Page"
-        });
-      }
-    }
-    ```
-    @method buildRouteInfoMetadata
-    @return any
-    @since 3.10.0
-    @public
-   */
-
 
   buildRouteInfoMetadata() {}
 
@@ -1329,7 +1097,8 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   get store() {
-    let owner = getOwner(this);
+    const owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let routeName = this.routeName;
     return {
       find(name, value) {
@@ -1361,6 +1130,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     let combinedQueryParameterConfiguration;
     let controllerName = this.controllerName || this.routeName;
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let controller = owner.lookup(`controller:${controllerName}`);
     let queryParameterConfiguraton = get(this, 'queryParams');
     let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
@@ -1370,7 +1140,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       // this route find its query params and normalize their object shape them
       // merge in the query params for the route. As a mergedProperty,
       // Route#queryParams is always at least `{}`
-      let controllerDefinedQueryParameterConfiguration = get(controller, 'queryParams') || {};
+      let controllerDefinedQueryParameterConfiguration = get(controller, 'queryParams') || [];
       let normalizedControllerQueryParameterConfiguration = normalizeControllerQueryParams(controllerDefinedQueryParameterConfiguration);
       combinedQueryParameterConfiguration = mergeEachQueryParams(normalizedControllerQueryParameterConfiguration, queryParameterConfiguraton);
     } else if (hasRouterDefinedQueryParams) {
@@ -1398,7 +1168,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
       let desc = combinedQueryParameterConfiguration[propName];
       let scope = desc.scope || 'model';
-      let parts;
+      let parts = undefined;
 
       if (scope === 'controller') {
         parts = [];
@@ -1442,6 +1212,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
         */
         inactive: (prop, value) => {
           let qp = map[prop];
+          assert('expected inactive callback to only be called for registered qps', qp);
 
           this._qpChanged(prop, value, qp);
         },
@@ -1453,6 +1224,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
         */
         active: (prop, value) => {
           let qp = map[prop];
+          assert('expected active callback to only be called for registered qps', qp);
 
           this._qpChanged(prop, value, qp);
 
@@ -1465,6 +1237,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
         */
         allowOverrides: (prop, value) => {
           let qp = map[prop];
+          assert('expected allowOverrides callback to only be called for registered qps', qp);
 
           this._qpChanged(prop, value, qp);
 
@@ -1495,7 +1268,9 @@ function routeInfoFor(route, routeInfos, offset = 0) {
   let current;
 
   for (let i = 0; i < routeInfos.length; i++) {
-    current = routeInfos[i].route;
+    let routeInfo = routeInfos[i];
+    assert('has current routeInfo', routeInfo);
+    current = routeInfo.route;
 
     if (current === route) {
       return routeInfos[i + offset];
@@ -1522,6 +1297,7 @@ function buildRenderOptions(route, nameOrOptions, options) {
 
   assert('You passed undefined as the outlet name.', isDefaultRender || !(options && 'outlet' in options && options.outlet === undefined));
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let name, templateName, into, outlet, model;
   let controller = undefined;
 
@@ -1594,13 +1370,12 @@ function buildRenderOptions(route, nameOrOptions, options) {
 }
 
 export function getFullQueryParams(router, state) {
-  if (state['fullQueryParams']) {
-    return state['fullQueryParams'];
+  if (state.fullQueryParams) {
+    return state.fullQueryParams;
   }
 
-  let fullQueryParamsState = {};
   let haveAllRouteInfosResolved = state.routeInfos.every(routeInfo => routeInfo.route);
-  Object.assign(fullQueryParamsState, state.queryParams);
+  let fullQueryParamsState = Object.assign({}, state.queryParams);
 
   router._deserializeQueryParams(state.routeInfos, fullQueryParamsState); // only cache query params state if all routeinfos have resolved; it's possible
   // for lazy routes to not have resolved when `getFullQueryParams` is called, so
@@ -1608,37 +1383,40 @@ export function getFullQueryParams(router, state) {
 
 
   if (haveAllRouteInfosResolved) {
-    state['fullQueryParams'] = fullQueryParamsState;
+    state.fullQueryParams = fullQueryParamsState;
   }
 
   return fullQueryParamsState;
 }
 
 function getQueryParamsFor(route, state) {
-  state['queryParamsFor'] = state['queryParamsFor'] || {};
+  state.queryParamsFor = state.queryParamsFor || {};
   let name = route.fullRouteName;
+  let existing = state.queryParamsFor[name];
 
-  if (state['queryParamsFor'][name]) {
-    return state['queryParamsFor'][name];
+  if (existing) {
+    return existing;
   }
 
   let fullQueryParams = getFullQueryParams(route._router, state);
-  let params = state['queryParamsFor'][name] = {}; // Copy over all the query params for this route/controller into params hash.
+  let params = state.queryParamsFor[name] = {}; // Copy over all the query params for this route/controller into params hash.
+  // SAFETY: Since `_qp` is protected we can't infer the type
 
-  let qps = get(route, '_qp.qps');
+  let qps = get(route, '_qp').qps;
 
-  for (let i = 0; i < qps.length; ++i) {
+  for (let qp of qps) {
     // Put deserialized qp on params hash.
-    let qp = qps[i];
     let qpValueWasPassedIn = (qp.prop in fullQueryParams);
     params[qp.prop] = qpValueWasPassedIn ? fullQueryParams[qp.prop] : copyDefaultValue(qp.defaultValue);
   }
 
   return params;
-}
+} // FIXME: This should probably actually return a `NativeArray` if the passed in value is an Array.
+
 
 function copyDefaultValue(value) {
   if (Array.isArray(value)) {
+    // SAFETY: We lost the type data about the array if we don't cast.
     return emberA(value.slice());
   }
 
@@ -1718,54 +1496,12 @@ function getEngineRouteName(engine, routeName) {
 
   return routeName;
 }
-/**
-    A hook you can implement to convert the route's model into parameters
-    for the URL.
-
-    ```app/router.js
-    // ...
-
-    Router.map(function() {
-      this.route('post', { path: '/posts/:post_id' });
-    });
-
-    ```
-
-    ```app/routes/post.js
-    import Route from '@ember/routing/route';
 
-    export default class PostRoute extends Route {
-      model({ post_id }) {
-        // the server returns `{ id: 12 }`
-        return fetch(`/posts/${post_id}`;
-      }
-
-      serialize(model) {
-        // this will make the URL `/posts/12`
-        return { post_id: model.id };
-      }
-    }
-    ```
-
-    The default `serialize` method will insert the model's `id` into the
-    route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
-    If the route has multiple dynamic segments or does not contain '_id', `serialize`
-    will return `getProperties(model, params)`
-
-    This method is called when `transitionTo` is called with a context
-    in order to populate the URL.
-
-    @method serialize
-    @param {Object} model the routes model
-    @param {Array} params an Array of parameter names for the current
-      route (in the example, `['post_id']`.
-    @return {Object} the serialized parameters
-    @since 1.0.0
-    @public
-  */
-
-
-Route.prototype.serialize = defaultSerialize; // Set these here so they can be overridden with extend
+const defaultSerialize = Route.prototype.serialize;
+export { defaultSerialize };
+export function hasDefaultSerialize(route) {
+  return route.serialize === defaultSerialize;
+} // Set these here so they can be overridden with extend
 
 Route.reopen({
   mergedProperties: ['queryParams'],
@@ -1824,15 +1560,22 @@ Route.reopen({
     @private
     */
     queryParamsDidChange(changed, _totalPresent, removed) {
+      // SAFETY: Since `_qp` is protected we can't infer the type
       let qpMap = get(this, '_qp').map;
       let totalChanged = Object.keys(changed).concat(Object.keys(removed));
 
-      for (let i = 0; i < totalChanged.length; ++i) {
-        let qp = qpMap[totalChanged[i]];
+      for (let change of totalChanged) {
+        let qp = qpMap[change];
+
+        if (qp) {
+          let options = this._optionsForQueryParam(qp);
+
+          assert('options exists', options && typeof options === 'object');
 
-        if (qp && get(this._optionsForQueryParam(qp), 'refreshModel') && this._router.currentState) {
-          this.refresh();
-          break;
+          if (get(options, 'refreshModel') && this._router.currentState) {
+            this.refresh();
+            break;
+          }
         }
       }
 
@@ -1859,15 +1602,15 @@ Route.reopen({
       let replaceUrl;
       stashParamNames(router, routeInfos);
 
-      for (let i = 0; i < qpMeta.qps.length; ++i) {
-        let qp = qpMeta.qps[i];
+      for (let qp of qpMeta.qps) {
         let route = qp.route;
         let controller = route.controller;
         let presentKey = qp.urlKey in params && qp.urlKey; // Do a reverse lookup to see if the changed query
         // param URL key corresponds to a QP property on
         // this controller.
 
-        let value, svalue;
+        let value;
+        let svalue;
 
         if (changes.has(qp.urlKey)) {
           // Value updated in/before setupController
@@ -1885,9 +1628,10 @@ Route.reopen({
             svalue = qp.serializedDefaultValue;
             value = copyDefaultValue(qp.defaultValue);
           }
-        }
+        } // SAFETY: Since `_qp` is protected we can't infer the type
+
 
-        controller._qpDelegate = get(route, '_qp.states.inactive');
+        controller._qpDelegate = get(route, '_qp').states.inactive;
         let thisQueryParamChanged = svalue !== qp.serializedValue;
 
         if (thisQueryParamChanged) {
@@ -1932,6 +1676,7 @@ Route.reopen({
       }
 
       qpMeta.qps.forEach(qp => {
+        // SAFETY: Since `_qp` is protected we can't infer the type
         let routeQpMeta = get(qp.route, '_qp');
         let finalizedController = qp.route.controller;
         finalizedController['_qpDelegate'] = get(routeQpMeta, 'states.active');