ember-source 3.28.5 → 4.0.0-beta.10

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

@@ -1,12 +1,18 @@
+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 { privatize as P } from '@ember/-internals/container';
 import { addObserver, computed, defineProperty, descriptorForProperty, flushAsyncObservers, get, getProperties, isEmpty, set, setProperties } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { A as emberA, ActionHandler, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { isProxy, lookupDescriptor, symbol } from '@ember/-internals/utils';
-import { assert, deprecate, info, isTesting } from '@ember/debug';
-import { ROUTER_EVENTS } from '@ember/deprecated-features';
+import { assert, info, isTesting } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
-import { assign } from '@ember/polyfills';
 import { once } from '@ember/runloop';
 import { classify } from '@ember/string';
 import { DEBUG } from '@glimmer/env';
@@ -57,7 +63,7 @@ export function hasDefaultSerialize(route) {
   @public
 */
 
-class Route extends EmberObject {
+class Route extends EmberObject.extend(ActionHandler, Evented) {
   constructor(owner) {
     super(...arguments);
     this.context = {};
@@ -72,29 +78,6 @@ class Route extends EmberObject {
       this._environment = owner.lookup('-environment:main');
     }
   }
-  /**
-    The name of the route, dot-delimited.
-       For example, a route found at `app/routes/posts/post.js` will have
-    a `routeName` of `posts.post`.
-       @property routeName
-    @for Route
-    @type String
-    @since 1.0.0
-    @public
-  */
-
-  /**
-    The name of the route, dot-delimited, including the engine prefix
-    if applicable.
-       For example, a route found at `addon/routes/posts/post.js` within an
-    engine named `admin` will have a `fullRouteName` of `admin.posts.post`.
-       @property fullRouteName
-    @for Route
-    @type String
-    @since 2.10.0
-    @public
-  */
-
   /**
     Sets the name for this route, including a fully resolved name for routes
     inside engines.
@@ -214,7 +197,7 @@ class Route extends EmberObject {
     let transition = this._router._routerMicrolib.activeTransition;
     let state = transition ? transition[STATE_SYMBOL] : this._router._routerMicrolib.state;
     let fullName = route.fullRouteName;
-    let params = assign({}, state.params[fullName]);
+    let params = Object.assign({}, state.params[fullName]);
     let queryParams = getQueryParamsFor(route, state);
     return Object.keys(queryParams).reduce((params, key) => {
       assert(`The route '${this.routeName}' has both a dynamic segment and query param with name '${key}'. Please rename one to avoid collisions.`, !params[key]);
@@ -825,16 +808,7 @@ class Route extends EmberObject {
     this.setupController(controller, context, transition);
 
     if (this._environment.options.shouldRender) {
-      deprecate('Usage of `renderTemplate` is deprecated.', this.renderTemplate === Route.prototype.renderTemplate, {
-        id: 'route-render-template',
-        until: '4.0.0',
-        url: 'https://deprecations.emberjs.com/v3.x/#toc_route-render-template',
-        for: 'ember-source',
-        since: {
-          enabled: '3.27.0'
-        }
-      });
-      this.renderTemplate(controller, context);
+      this[RENDER]();
     } // Setup can cause changes to QPs which need to be propogated immediately in
     // some situations. Eventually, we should work on making these async somehow.
 
@@ -1123,7 +1097,7 @@ class Route extends EmberObject {
        @method setupController
     @param {Controller} controller instance
     @param {Object} model
-    @param {Object} transition
+    @param {Transition} [transition]
     @since 1.0.0
     @public
   */
@@ -1278,276 +1252,6 @@ class Route extends EmberObject {
     ROUTE_CONNECTIONS.get(this).push(renderOptions);
     once(this._router, '_setOutlets');
   }
-  /**
-    A hook you can use to render the template for the current route.
-       This method is called with the controller for the current route and the
-    model supplied by the `model` hook. By default, it renders the route's
-    template, configured with the controller for the route.
-       This method can be overridden to set up and render additional or
-    alternative templates.
-       ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-       export default class PostsRoute extends Route {
-      renderTemplate(controller, model) {
-        let favController = this.controllerFor('favoritePost');
-           // Render the `favoritePost` template into
-        // the outlet `posts`, and display the `favoritePost`
-        // controller.
-        this.render('favoritePost', {
-          outlet: 'posts',
-          controller: favController
-        });
-      }
-    }
-    ```
-       @method renderTemplate
-    @param {Object} controller the route's controller
-    @param {Object} model the route's model
-    @since 1.0.0
-    @public
-  */
-
-
-  renderTemplate(_controller, _model) {
-    // eslint-disable-line no-unused-vars
-    this[RENDER]();
-  }
-  /**
-    `render` is used to render a template into a region of another template
-    (indicated by an `{{outlet}}`). `render` is used both during the entry
-    phase of routing (via the `renderTemplate` hook) and later in response to
-    user interaction.
-       For example, given the following minimal router and templates:
-       ```app/router.js
-    // ...
-       Router.map(function() {
-      this.route('photos');
-    });
-       export default Router;
-    ```
-       ```handlebars
-    <!-- application.hbs -->
-    <div class='something-in-the-app-hbs'>
-      {{outlet "anOutletName"}}
-    </div>
-    ```
-       ```handlebars
-    <!-- photos.hbs -->
-    <h1>Photos</h1>
-    ```
-       You can render `photos.hbs` into the `"anOutletName"` outlet of
-    `application.hbs` by calling `render`:
-       ```app/routes/post.js
-    import Route from '@ember/routing/route';
-       export default class PostRoute extends Route {
-      renderTemplate() {
-        this.render('photos', {
-          into: 'application',
-          outlet: 'anOutletName'
-        })
-      }
-    }
-    ```
-       `render` additionally allows you to supply which `controller` and
-    `model` objects should be loaded and associated with the rendered template.
-       ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-       export default class PostsRoute extends Route {
-      renderTemplate(controller, model) {
-        this.render('posts', {    // the template to render, referenced by name
-          into: 'application',    // the template to render into, referenced by name
-          outlet: 'anOutletName', // the outlet inside `options.into` to render into.
-          controller: 'someControllerName', // the controller to use for this template, referenced by name
-          model: model            // the model to set on `options.controller`.
-        })
-      }
-    }
-    ```
-       The string values provided for the template name, and controller
-    will eventually pass through to the resolver for lookup. See
-    Resolver for how these are mapped to JavaScript objects in your
-    application. The template to render into needs to be related to  either the
-    current route or one of its ancestors.
-       Not all options need to be passed to `render`. Default values will be used
-    based on the name of the route specified in the router or the Route's
-    `controllerName` and `templateName` properties.
-       For example:
-       ```app/router.js
-    // ...
-       Router.map(function() {
-      this.route('index');
-      this.route('post', { path: '/posts/:post_id' });
-    });
-       export default Router;
-    ```
-       ```app/routes/post.js
-    import Route from '@ember/routing/route';
-       export default class PostRoute extends Route {
-      renderTemplate() {
-        this.render(); // all defaults apply
-      }
-    }
-    ```
-       The name of the route, defined by the router, is `post`.
-       The following equivalent default options will be applied when
-    the Route calls `render`:
-       ```javascript
-    this.render('post', {  // the template name associated with 'post' Route
-      into: 'application', // the parent route to 'post' Route
-      outlet: 'main',      // {{outlet}} and {{outlet 'main'}} are synonymous,
-      controller: 'post',  // the controller associated with the 'post' Route
-    })
-    ```
-       By default the controller's `model` will be the route's model, so it does not
-    need to be passed unless you wish to change which model is being used.
-       @method render
-    @param {String} name the name of the template to render
-    @param {Object} [options] the options
-    @param {String} [options.into] the template to render into,
-                    referenced by name. Defaults to the parent template
-    @param {String} [options.outlet] the outlet inside `options.into` to render into.
-                    Defaults to 'main'
-    @param {String|Object} [options.controller] the controller to use for this template,
-                    referenced by name or as a controller instance. Defaults to the Route's paired controller
-    @param {Object} [options.model] the model object to set on `options.controller`.
-                    Defaults to the return value of the Route's model hook
-    @since 1.0.0
-    @public
-  */
-
-
-  render(name, options) {
-    deprecate(`Usage of \`render\` is deprecated. Route: \`${this.routeName}\``, false, {
-      id: 'route-render-template',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x/#toc_route-render-template',
-      for: 'ember-source',
-      since: {
-        enabled: '3.27.0'
-      }
-    });
-    this[RENDER](name, options);
-  }
-  /**
-    Disconnects a view that has been rendered into an outlet.
-       You may pass any or all of the following options to `disconnectOutlet`:
-       * `outlet`: the name of the outlet to clear (default: 'main')
-    * `parentView`: the name of the view containing the outlet to clear
-       (default: the view rendered by the parent route)
-       Example:
-       ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class ApplicationRoute extends Route {
-      @action
-      showModal(evt) {
-        this.render(evt.modalName, {
-          outlet: 'modal',
-          into: 'application'
-        });
-      }
-         @action
-      hideModal() {
-        this.disconnectOutlet({
-          outlet: 'modal',
-          parentView: 'application'
-        });
-      }
-    }
-    ```
-       Alternatively, you can pass the `outlet` name directly as a string.
-       Example:
-       ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class ApplicationRoute extends Route {
-      @action
-      showModal(evt) {
-        // ...
-      }
-         @action
-      hideModal(evt) {
-        this.disconnectOutlet('modal');
-      }
-    }
-    ```
-       @method disconnectOutlet
-    @param {Object|String} options the options hash or outlet name
-    @since 1.0.0
-    @public
-  */
-
-
-  disconnectOutlet(options) {
-    deprecate('The usage of `disconnectOutlet` is deprecated.', false, {
-      id: 'route-disconnect-outlet',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x/#toc_route-disconnect-outlet',
-      for: 'ember-source',
-      since: {
-        enabled: '3.27.0'
-      }
-    });
-    let outletName;
-    let parentView;
-
-    if (options) {
-      if (typeof options === 'string') {
-        outletName = options;
-      } else {
-        outletName = options.outlet;
-        parentView = options.parentView ? options.parentView.replace(/\//g, '.') : undefined;
-        assert('You passed undefined as the outlet name.', !('outlet' in options && options.outlet === undefined));
-      }
-    }
-
-    outletName = outletName || 'main';
-
-    this._disconnectOutlet(outletName, parentView);
-
-    let routeInfos = this._router._routerMicrolib.currentRouteInfos;
-
-    for (let i = 0; i < routeInfos.length; i++) {
-      // This non-local state munging is sadly necessary to maintain
-      // backward compatibility with our existing semantics, which allow
-      // any route to disconnectOutlet things originally rendered by any
-      // other route. This should all get cut in 2.0.
-      routeInfos[i].route._disconnectOutlet(outletName, parentView);
-    }
-  }
-
-  _disconnectOutlet(outletName, parentView) {
-    let parent = parentRoute(this);
-
-    if (parent && parentView === parent.routeName) {
-      parentView = undefined;
-    }
-
-    let connections = ROUTE_CONNECTIONS.get(this);
-
-    for (let i = 0; i < connections.length; i++) {
-      let connection = connections[i];
-
-      if (connection.outlet === outletName && connection.into === parentView) {
-        // This neuters the disconnected outlet such that it doesn't
-        // render anything, but it leaves an entry in the outlet
-        // hierarchy so that any existing other renders that target it
-        // don't suddenly blow up. They will still stick themselves
-        // into its outlets, which won't render anywhere. All of this
-        // statefulness should get the machete in 2.0.
-        connections[i] = {
-          owner: connection.owner,
-          into: connection.into,
-          outlet: connection.outlet,
-          name: connection.name,
-          controller: undefined,
-          template: undefined,
-          model: undefined
-        };
-        once(this._router, '_setOutlets');
-      }
-    }
-  }
 
   willDestroy() {
     this.teardownViews();
@@ -1602,11 +1306,181 @@ class Route extends EmberObject {
 
   buildRouteInfoMetadata() {}
 
+  _paramsFor(routeName, params) {
+    let transition = this._router._routerMicrolib.activeTransition;
+
+    if (transition !== undefined) {
+      return this.paramsFor(routeName);
+    }
+
+    return params;
+  }
+  /**
+    Store property provides a hook for data persistence libraries to inject themselves.
+       By default, this store property provides the exact same functionality previously
+    in the model hook.
+       Currently, the required interface is:
+       `store.find(modelName, findArguments)`
+       @property store
+    @type {Object}
+    @private
+  */
+
+
+  get store() {
+    let owner = getOwner(this);
+    let routeName = this.routeName;
+    let namespace = get(this, '_router.namespace');
+    return {
+      find(name, value) {
+        let modelClass = owner.factoryFor(`model:${name}`);
+        assert(`You used the dynamic segment ${name}_id in your route ${routeName}, but ${namespace}.${classify(name)} did not exist and you did not override your route's \`model\` hook.`, Boolean(modelClass));
+
+        if (!modelClass) {
+          return;
+        }
+
+        modelClass = modelClass.class;
+        assert(`${classify(name)} has no method \`find\`.`, typeof modelClass.find === 'function');
+        return modelClass.find(value);
+      }
+
+    };
+  }
+
+  set store(value) {
+    defineProperty(this, 'store', null, value);
+  }
+  /**
+    @private
+    @property _qp
+    */
+
+
+  get _qp() {
+    let combinedQueryParameterConfiguration;
+    let controllerName = this.controllerName || this.routeName;
+    let owner = getOwner(this);
+    let controller = owner.lookup(`controller:${controllerName}`);
+    let queryParameterConfiguraton = get(this, 'queryParams');
+    let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
+
+    if (controller) {
+      // the developer has authored a controller class in their application for
+      // 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 normalizedControllerQueryParameterConfiguration = normalizeControllerQueryParams(controllerDefinedQueryParameterConfiguration);
+      combinedQueryParameterConfiguration = mergeEachQueryParams(normalizedControllerQueryParameterConfiguration, queryParameterConfiguraton);
+    } else if (hasRouterDefinedQueryParams) {
+      // the developer has not defined a controller but *has* supplied route query params.
+      // Generate a class for them so we can later insert default values
+      controller = generateController(owner, controllerName);
+      combinedQueryParameterConfiguration = queryParameterConfiguraton;
+    }
+
+    let qps = [];
+    let map = {};
+    let propertyNames = [];
+
+    for (let propName in combinedQueryParameterConfiguration) {
+      if (!Object.prototype.hasOwnProperty.call(combinedQueryParameterConfiguration, propName)) {
+        continue;
+      } // to support the dubious feature of using unknownProperty
+      // on queryParams configuration
+
+
+      if (propName === 'unknownProperty' || propName === '_super') {
+        // possible todo: issue deprecation warning?
+        continue;
+      }
+
+      let desc = combinedQueryParameterConfiguration[propName];
+      let scope = desc.scope || 'model';
+      let parts;
+
+      if (scope === 'controller') {
+        parts = [];
+      }
+
+      let urlKey = desc.as || this.serializeQueryParamKey(propName);
+      let defaultValue = get(controller, propName);
+      defaultValue = copyDefaultValue(defaultValue);
+      let type = desc.type || typeOf(defaultValue);
+      let defaultValueSerialized = this.serializeQueryParam(defaultValue, urlKey, type);
+      let scopedPropertyName = `${controllerName}:${propName}`;
+      let qp = {
+        undecoratedDefaultValue: get(controller, propName),
+        defaultValue,
+        serializedDefaultValue: defaultValueSerialized,
+        serializedValue: defaultValueSerialized,
+        type,
+        urlKey,
+        prop: propName,
+        scopedPropertyName,
+        controllerName,
+        route: this,
+        parts,
+        values: null,
+        scope
+      };
+      map[propName] = map[urlKey] = map[scopedPropertyName] = qp;
+      qps.push(qp);
+      propertyNames.push(propName);
+    }
+
+    return {
+      qps,
+      map,
+      propertyNames,
+      states: {
+        /*
+          Called when a query parameter changes in the URL, this route cares
+          about that query parameter, but the route is not currently
+          in the active route hierarchy.
+        */
+        inactive: (prop, value) => {
+          let qp = map[prop];
+
+          this._qpChanged(prop, value, qp);
+        },
+
+        /*
+          Called when a query parameter changes in the URL, this route cares
+          about that query parameter, and the route is currently
+          in the active route hierarchy.
+        */
+        active: (prop, value) => {
+          let qp = map[prop];
+
+          this._qpChanged(prop, value, qp);
+
+          return this._activeQPChanged(qp, value);
+        },
+
+        /*
+          Called when a value of a query parameter this route handles changes in a controller
+          and the route is currently in the active route hierarchy.
+        */
+        allowOverrides: (prop, value) => {
+          let qp = map[prop];
+
+          this._qpChanged(prop, value, qp);
+
+          return this._updatingQPChanged(qp);
+        }
+      }
+    };
+  }
+
 }
 
-Route.reopenClass({
-  isRouteFactory: true
-});
+Route.isRouteFactory = true;
+
+__decorate([computed], Route.prototype, "store", null);
+
+__decorate([computed], Route.prototype, "_qp", null);
 
 function parentRoute(route) {
   let routeInfo = routeInfoFor(route, route._router._routerMicrolib.state.routeInfos, -1);
@@ -1726,7 +1600,7 @@ export function getFullQueryParams(router, state) {
 
   let fullQueryParamsState = {};
   let haveAllRouteInfosResolved = state.routeInfos.every(routeInfo => routeInfo.route);
-  assign(fullQueryParamsState, state.queryParams);
+  Object.assign(fullQueryParamsState, 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
@@ -1793,7 +1667,7 @@ function mergeEachQueryParams(controllerQP, routeQP) {
     }
 
     let newControllerParameterConfiguration = {};
-    assign(newControllerParameterConfiguration, controllerQP[cqpName], routeQP[cqpName]);
+    Object.assign(newControllerParameterConfiguration, controllerQP[cqpName], routeQP[cqpName]);
     qps[cqpName] = newControllerParameterConfiguration; // allows us to skip this QP when we check route QPs.
 
     keysAlreadyMergedOrSkippable[cqpName] = true;
@@ -1807,7 +1681,7 @@ function mergeEachQueryParams(controllerQP, routeQP) {
     }
 
     let newRouteParameterConfiguration = {};
-    assign(newRouteParameterConfiguration, routeQP[rqpName], controllerQP[rqpName]);
+    Object.assign(newRouteParameterConfiguration, routeQP[rqpName], controllerQP[rqpName]);
     qps[rqpName] = newRouteParameterConfiguration;
   }
 
@@ -1891,298 +1765,14 @@ function getEngineRouteName(engine, routeName) {
   */
 
 
-Route.prototype.serialize = defaultSerialize;
-Route.reopen(ActionHandler, Evented, {
-  mergedProperties: ['queryParams'],
+Route.prototype.serialize = defaultSerialize; // Set these here so they can be overridden with extend
 
-  /**
-    Configuration hash for this route's queryParams. The possible
-    configuration options and their defaults are as follows
-    (assuming a query param whose controller property is `page`):
-       ```javascript
-    queryParams: {
-      page: {
-        // By default, controller query param properties don't
-        // cause a full transition when they are changed, but
-        // rather only cause the URL to update. Setting
-        // `refreshModel` to true will cause an "in-place"
-        // transition to occur, whereby the model hooks for
-        // this route (and any child routes) will re-fire, allowing
-        // you to reload models (e.g., from the server) using the
-        // updated query param values.
-        refreshModel: false,
-           // By default, changes to controller query param properties
-        // cause the URL to update via `pushState`, which means an
-        // item will be added to the browser's history, allowing
-        // you to use the back button to restore the app to the
-        // previous state before the query param property was changed.
-        // Setting `replace` to true will use `replaceState` (or its
-        // hash location equivalent), which causes no browser history
-        // item to be added. This options name and default value are
-        // the same as the `link-to` helper's `replace` option.
-        replace: false,
-           // By default, the query param URL key is the same name as
-        // the controller property name. Use `as` to specify a
-        // different URL key.
-        as: 'page'
-      }
-    }
-    ```
-       @property queryParams
-    @for Route
-    @type Object
-    @since 1.6.0
-    @public
-  */
+Route.reopen({
+  mergedProperties: ['queryParams'],
   queryParams: {},
-
-  /**
-    The name of the template to use by default when rendering this routes
-    template.
-       ```app/routes/posts/list.js
-    import Route from '@ember/routing/route';
-       export default class extends Route {
-      templateName = 'posts/list'
-    });
-    ```
-       ```app/routes/posts/index.js
-    import PostsList from '../posts/list';
-       export default class extends PostsList {};
-    ```
-       ```app/routes/posts/archived.js
-    import PostsList from '../posts/list';
-       export default class extends PostsList {};
-    ```
-       @property templateName
-    @type String
-    @default null
-    @since 1.4.0
-    @public
-  */
   templateName: null,
-
-  /**
-    @private
-       @property _names
-  */
-  _names: null,
-
-  /**
-    The name of the controller to associate with this route.
-       By default, Ember will lookup a route's controller that matches the name
-    of the route (i.e. `posts.new`). However,
-    if you would like to define a specific controller to use, you can do so
-    using this property.
-       This is useful in many ways, as the controller specified will be:
-       * passed to the `setupController` method.
-    * used as the controller for the template being rendered by the route.
-    * returned from a call to `controllerFor` for the route.
-       @property controllerName
-    @type String
-    @default null
-    @since 1.4.0
-    @public
-  */
   controllerName: null,
 
-  /**
-    Store property provides a hook for data persistence libraries to inject themselves.
-       By default, this store property provides the exact same functionality previously
-    in the model hook.
-       Currently, the required interface is:
-       `store.find(modelName, findArguments)`
-       @property store
-    @type {Object}
-    @private
-  */
-  store: computed({
-    get() {
-      let owner = getOwner(this);
-      let routeName = this.routeName;
-      let namespace = get(this, '_router.namespace');
-      return {
-        find(name, value) {
-          let modelClass = owner.factoryFor(`model:${name}`);
-          assert(`You used the dynamic segment ${name}_id in your route ${routeName}, but ${namespace}.${classify(name)} did not exist and you did not override your route's \`model\` hook.`, Boolean(modelClass));
-
-          if (!modelClass) {
-            return;
-          }
-
-          modelClass = modelClass.class;
-          assert(`${classify(name)} has no method \`find\`.`, typeof modelClass.find === 'function');
-          return modelClass.find(value);
-        }
-
-      };
-    },
-
-    set(key, value) {
-      defineProperty(this, key, null, value);
-    }
-
-  }),
-
-  /**
-      @private
-         @property _qp
-    */
-  _qp: computed(function () {
-    let combinedQueryParameterConfiguration;
-    let controllerName = this.controllerName || this.routeName;
-    let owner = getOwner(this);
-    let controller = owner.lookup(`controller:${controllerName}`);
-    let queryParameterConfiguraton = get(this, 'queryParams');
-    let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
-
-    if (controller) {
-      // the developer has authored a controller class in their application for
-      // 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 normalizedControllerQueryParameterConfiguration = normalizeControllerQueryParams(controllerDefinedQueryParameterConfiguration);
-      combinedQueryParameterConfiguration = mergeEachQueryParams(normalizedControllerQueryParameterConfiguration, queryParameterConfiguraton);
-    } else if (hasRouterDefinedQueryParams) {
-      // the developer has not defined a controller but *has* supplied route query params.
-      // Generate a class for them so we can later insert default values
-      controller = generateController(owner, controllerName);
-      combinedQueryParameterConfiguration = queryParameterConfiguraton;
-    }
-
-    let qps = [];
-    let map = {};
-    let propertyNames = [];
-
-    for (let propName in combinedQueryParameterConfiguration) {
-      if (!Object.prototype.hasOwnProperty.call(combinedQueryParameterConfiguration, propName)) {
-        continue;
-      } // to support the dubious feature of using unknownProperty
-      // on queryParams configuration
-
-
-      if (propName === 'unknownProperty' || propName === '_super') {
-        // possible todo: issue deprecation warning?
-        continue;
-      }
-
-      let desc = combinedQueryParameterConfiguration[propName];
-      let scope = desc.scope || 'model';
-      let parts;
-
-      if (scope === 'controller') {
-        parts = [];
-      }
-
-      let urlKey = desc.as || this.serializeQueryParamKey(propName);
-      let defaultValue = get(controller, propName);
-      defaultValue = copyDefaultValue(defaultValue);
-      let type = desc.type || typeOf(defaultValue);
-      let defaultValueSerialized = this.serializeQueryParam(defaultValue, urlKey, type);
-      let scopedPropertyName = `${controllerName}:${propName}`;
-      let qp = {
-        undecoratedDefaultValue: get(controller, propName),
-        defaultValue,
-        serializedDefaultValue: defaultValueSerialized,
-        serializedValue: defaultValueSerialized,
-        type,
-        urlKey,
-        prop: propName,
-        scopedPropertyName,
-        controllerName,
-        route: this,
-        parts,
-        values: null,
-        scope
-      };
-      map[propName] = map[urlKey] = map[scopedPropertyName] = qp;
-      qps.push(qp);
-      propertyNames.push(propName);
-    }
-
-    return {
-      qps,
-      map,
-      propertyNames,
-      states: {
-        /*
-          Called when a query parameter changes in the URL, this route cares
-          about that query parameter, but the route is not currently
-          in the active route hierarchy.
-        */
-        inactive: (prop, value) => {
-          let qp = map[prop];
-
-          this._qpChanged(prop, value, qp);
-        },
-
-        /*
-          Called when a query parameter changes in the URL, this route cares
-          about that query parameter, and the route is currently
-          in the active route hierarchy.
-        */
-        active: (prop, value) => {
-          let qp = map[prop];
-
-          this._qpChanged(prop, value, qp);
-
-          return this._activeQPChanged(qp, value);
-        },
-
-        /*
-          Called when a value of a query parameter this route handles changes in a controller
-          and the route is currently in the active route hierarchy.
-        */
-        allowOverrides: (prop, value) => {
-          let qp = map[prop];
-
-          this._qpChanged(prop, value, qp);
-
-          return this._updatingQPChanged(qp);
-        }
-      }
-    };
-  }),
-
-  /**
-    Sends an action to the router, which will delegate it to the currently
-    active route hierarchy per the bubbling rules explained under `actions`.
-       Example
-       ```app/router.js
-    // ...
-       Router.map(function() {
-      this.route('index');
-    });
-       export default Router;
-    ```
-       ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class ApplicationRoute extends Route {
-      @action
-      track(arg) {
-        console.log(arg, 'was clicked');
-      }
-    }
-    ```
-       ```app/routes/index.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-       export default class IndexRoute extends Route {
-      @action
-      trackIfDebug(arg) {
-        if (debug) {
-          this.send('track', arg);
-        }
-      }
-    }
-    ```
-       @method send
-    @param {String} name the name of the action to trigger
-    @param {...*} args
-    @since 1.0.0
-    @public
-  */
   send(...args) {
     assert(`Attempted to call .send() with the action '${args[0]}' on the destroyed route '${this.routeName}'.`, !this.isDestroying && !this.isDestroyed);
 
@@ -2354,54 +1944,4 @@ Route.reopen(ActionHandler, Evented, {
 
   }
 });
-export let ROUTER_EVENT_DEPRECATIONS;
-
-if (ROUTER_EVENTS) {
-  ROUTER_EVENT_DEPRECATIONS = {
-    on(name) {
-      this._super(...arguments);
-
-      let hasDidTransition = name === 'didTransition';
-      let hasWillTransition = name === 'willTransition';
-
-      if (hasDidTransition) {
-        deprecate('You attempted to listen to the "didTransition" event which is deprecated. Please inject the router service and listen to the "routeDidChange" event.', false, {
-          id: 'deprecate-router-events',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_deprecate-router-events',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-      }
-
-      if (hasWillTransition) {
-        deprecate('You attempted to listen to the "willTransition" event which is deprecated. Please inject the router service and listen to the "routeWillChange" event.', false, {
-          id: 'deprecate-router-events',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_deprecate-router-events',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-      }
-    }
-
-  };
-  Route.reopen(ROUTER_EVENT_DEPRECATIONS, {
-    _paramsFor(routeName, params) {
-      let transition = this._router._routerMicrolib.activeTransition;
-
-      if (transition !== undefined) {
-        return this.paramsFor(routeName);
-      }
-
-      return params;
-    }
-
-  });
-}
-
 export default Route;