ember-source 6.12.0 → 7.0.0-beta.1

package/dist/prod/packages/@ember/routing/route.js

@@ -0,0 +1,1604 @@
+import { privatize } from '../-internals/container/index.js';
+import { getOwner } from '../-internals/owner/index.js';
+import '../../shared-chunks/super-Cm_a_cLQ.js';
+import { l as lookupDescriptor } from '../../shared-chunks/lookup-descriptor-CwcVgaLv.js';
+import { i as isProxy } from '../../shared-chunks/is_proxy-Cr1qlMv_.js';
+import '../-internals/environment/index.js';
+import { isTesting } from '../debug/lib/testing.js';
+import { d as defineProperty, c as computed } from '../../shared-chunks/namespace_search-Aog9nySA.js';
+import '../../@glimmer/validator/index.js';
+import { b as hasInternalComponentManager } from '../../shared-chunks/api-Co-k4HVs.js';
+import '../../shared-chunks/reference-BNqcwZWH.js';
+import '../../shared-chunks/capabilities-DGmQ_mz4.js';
+import { d as descriptorForProperty } from '../../shared-chunks/decorator-BdDDBUd2.js';
+import { g as get, j as flushAsyncObservers, c as addObserver } from '../../shared-chunks/observers-R1ZklwWy.js';
+import { s as set } from '../../shared-chunks/property_set-O080KTKZ.js';
+import { g as getProperties, s as setProperties } from '../../shared-chunks/set_properties-CjsDTRey.js';
+import EmberObject from '../object/index.js';
+import Evented from '../object/evented.js';
+import { A } from '../array/index.js';
+import '../-internals/runtime/lib/mixins/registry_proxy.js';
+import '../-internals/runtime/lib/mixins/container_proxy.js';
+import '../-internals/runtime/lib/mixins/comparable.js';
+import ActionHandler from '../-internals/runtime/lib/mixins/action_handler.js';
+import '../-internals/runtime/lib/mixins/-proxy.js';
+import '../enumerable/mutable.js';
+import '../-internals/runtime/lib/mixins/target_action_support.js';
+import '../-internals/runtime/lib/ext/rsvp.js';
+import typeOf from '../utils/lib/type-of.js';
+import '../controller/index.js';
+import '../engine/instance.js';
+import { dependentKeyCompat } from '../object/compat.js';
+import { once } from '../runloop/index.js';
+import '../../route-recognizer/index.js';
+import '../../shared-chunks/rsvp-CnCSY930.js';
+import { S as STATE_SYMBOL, P as PARAMS_SYMBOL } from '../../shared-chunks/unrecognized-url-error-DDBwfzdm.js';
+import generateController from './lib/generate_controller.js';
+import { prefixRouteNameArg, stashParamNames, calculateCacheKey, normalizeControllerQueryParams } from './lib/utils.js';
+import { a as decorateMethodV2 } from '../../shared-chunks/chunk-3SQBS3Y5-Cj4eryg1.js';
+
+const RENDER = Symbol('render');
+const RENDER_STATE = Symbol('render-state');
+
+/**
+@module @ember/routing/route
+*/
+
+/**
+  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) {
+  static isRouteFactory = true;
+
+  // These properties will end up appearing in the public interface because we
+  // `implements IRoute` from `router.js`, which has them as part of *its*
+  // public contract. We mark them as `@internal` so they at least signal to
+  // people subclassing `Route` that they should not use them.
+  /** @internal */
+  context = {};
+  /** @internal */
+
+  /** @internal */
+  _bucketCache;
+  /** @internal */
+  _internalName;
+  _names;
+  _router;
+  constructor(owner) {
+    super(owner);
+    if (owner) {
+      let router = owner.lookup('router:main');
+      let bucketCache = owner.lookup(privatize`-bucket-cache:main`);
+      this._router = router;
+      this._bucketCache = bucketCache;
+      this._topLevelViewTemplate = owner.lookup('template:-outlet');
+      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;
+      if (typeof model === 'object' && 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;
+  }
+
+  /**
+    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
+  */
+  // Set in reopen so it can be overriden with extend
+
+  /**
+    The name of the template to use by default when rendering this route's
+    template.
+     ```app/routes/posts/list.js
+    import Route from '@ember/routing/route';
+     export default class PostsListRoute extends Route {
+      templateName = 'posts/list';
+    }
+    ```
+     ```app/routes/posts/index.js
+    import PostsListRoute from '../posts/list';
+     export default class PostsIndexRoute extends PostsListRoute {};
+    ```
+     ```app/routes/posts/archived.js
+    import PostsListRoute from '../posts/list';
+     export default class PostsArchivedRoute extends PostsListRoute {};
+    ```
+     @property templateName
+    @type String
+    @default null
+    @since 1.4.0
+    @public
+  */
+  // Set in reopen so it can be overriden with extend
+
+  /**
+    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
+  */
+  // Set in reopen so it can be overriden with extend
+
+  /**
+    The controller associated with this route.
+     Example
+     ```app/routes/form.js
+    import Route from '@ember/routing/route';
+    import { action } from '@ember/object';
+     export default class FormRoute extends Route {
+      @action
+      willTransition(transition) {
+        if (this.controller.get('userHasEnteredData') &&
+            !confirm('Are you sure you want to abandon progress?')) {
+          transition.abort();
+        } else {
+          // Bubble the `willTransition` action so that
+          // parent routes can decide whether or not to abort.
+          return true;
+        }
+      }
+    }
+    ```
+     @property controller
+    @type Controller
+    @since 1.6.0
+    @public
+  */
+
+  /**
+    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.
+     @private
+    @method _setRouteName
+    @param {String} name
+  */
+  _setRouteName(name) {
+    this.routeName = name;
+    let owner = getOwner(this);
+    this.fullRouteName = getEngineRouteName(owner, name);
+  }
+
+  /**
+    @private
+     @method _stashNames
+  */
+  _stashNames(routeInfo, dynamicParent) {
+    if (this._names) {
+      return;
+    }
+    let names = this._names = routeInfo['_names'];
+    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 namePaths = new Array(names.length);
+    for (let a = 0; a < names.length; ++a) {
+      namePaths[a] = `${routeInfo.name}.${names[a]}`;
+    }
+    for (let qp of qps) {
+      if (qp.scope === 'model') {
+        qp.parts = namePaths;
+      }
+    }
+  }
+
+  /**
+    @private
+     @property _activeQPChanged
+  */
+  _activeQPChanged(qp, value) {
+    this._router._activeQPChanged(qp.scopedPropertyName, value);
+  }
+
+  /**
+    @private
+    @method _updatingQPChanged
+  */
+  _updatingQPChanged(qp) {
+    this._router._updatingQPChanged(qp.urlKey);
+  }
+
+  /**
+    Returns a hash containing the parameters of an ancestor route.
+     You may notice that `this.paramsFor` sometimes works when referring to a
+    child route, but this behavior should not be relied upon as only ancestor
+    routes are certain to be loaded in time.
+     Example
+     ```app/router.js
+    // ...
+     Router.map(function() {
+      this.route('member', { path: ':name' }, function() {
+        this.route('interest', { path: ':interest' });
+      });
+    });
+    ```
+     ```app/routes/member.js
+    import Route from '@ember/routing/route';
+     export default class MemberRoute extends Route {
+      queryParams = {
+        memberQp: { refreshModel: true }
+      }
+    }
+    ```
+     ```app/routes/member/interest.js
+    import Route from '@ember/routing/route';
+     export default class MemberInterestRoute extends Route {
+      queryParams = {
+        interestQp: { refreshModel: true }
+      }
+       model() {
+        return this.paramsFor('member');
+      }
+    }
+    ```
+     If we visit `/turing/maths?memberQp=member&interestQp=interest` the model for
+    the `member.interest` route is a hash with:
+     * `name`: `turing`
+    * `memberQp`: `member`
+     @method paramsFor
+    @param {String} name
+    @return {Object} hash containing the parameters of the route `name`
+    @since 1.4.0
+    @public
+  */
+  paramsFor(name) {
+    let owner = getOwner(this);
+    let route = owner.lookup(`route:${name}`);
+    if (route === undefined) {
+      return {};
+    }
+    let transition = this._router._routerMicrolib.activeTransition;
+    let state = transition ? transition[STATE_SYMBOL] : this._router._routerMicrolib.state;
+    let fullName = route.fullRouteName;
+    let params = {
+      ...state.params[fullName]
+    };
+    let queryParams = getQueryParamsFor(route, state);
+    return Object.entries(queryParams).reduce((params, [key, value]) => {
+      params[key] = value;
+      return params;
+    }, params);
+  }
+
+  /**
+    Serializes the query parameter key
+     @method serializeQueryParamKey
+    @param {String} controllerPropertyName
+    @private
+  */
+  serializeQueryParamKey(controllerPropertyName) {
+    return controllerPropertyName;
+  }
+
+  /**
+    Serializes value of the query parameter based on defaultValueType
+     @method serializeQueryParam
+    @param {Object} value
+    @param {String} urlKey
+    @param {String} defaultValueType
+    @private
+  */
+  serializeQueryParam(value, _urlKey, defaultValueType) {
+    // urlKey isn't used here, but anyone overriding
+    // can use it to provide serialization specific
+    // to a certain query param.
+    return this._router._serializeQueryParam(value, defaultValueType);
+  }
+
+  /**
+    Deserializes value of the query parameter based on defaultValueType
+     @method deserializeQueryParam
+    @param {Object} value
+    @param {String} urlKey
+    @param {String} defaultValueType
+    @private
+  */
+  deserializeQueryParam(value, _urlKey, defaultValueType) {
+    // urlKey isn't used here, but anyone overriding
+    // can use it to provide deserialization specific
+    // to a certain query param.
+    return this._router._deserializeQueryParam(value, defaultValueType);
+  }
+
+  /**
+    @private
+     @property _optionsForQueryParam
+  */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  _optionsForQueryParam(qp) {
+    const queryParams = get(this, 'queryParams');
+    return get(queryParams, qp.urlKey) || get(queryParams, qp.prop) || queryParams[qp.urlKey] || queryParams[qp.prop] || {};
+  }
+
+  /**
+    A hook you can use to reset controller values either when the model
+    changes or the route is exiting.
+     ```app/routes/articles.js
+    import Route from '@ember/routing/route';
+     export default class ArticlesRoute extends Route {
+      resetController(controller, isExiting, transition) {
+        if (isExiting && transition.targetName !== 'error') {
+          controller.set('page', 1);
+        }
+      }
+    }
+    ```
+     @method resetController
+    @param {Controller} controller instance
+    @param {Boolean} isExiting
+    @param {Object} transition
+    @since 1.7.0
+    @public
+  */
+  resetController(_controller, _isExiting, _transition) {
+    // We document that subclasses do not have to return *anything* and in fact
+    // do not even have to call super, so whiel we *do* return `this`, we need
+    // to be explicit in the types that our return type is *effectively* `void`.
+    return this;
+  }
+
+  /**
+    @private
+     @method exit
+  */
+  exit(transition) {
+    this.deactivate(transition);
+    this.trigger('deactivate', transition);
+    this.teardownViews();
+  }
+
+  /**
+    @private
+     @method _internalReset
+    @since 3.6.0
+  */
+  _internalReset(isExiting, transition) {
+    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);
+  }
+
+  /**
+    @private
+     @method enter
+  */
+  enter(transition) {
+    this[RENDER_STATE] = undefined;
+    this.activate(transition);
+    this.trigger('activate', transition);
+  }
+
+  /**
+    This event is triggered when the router enters the route. It is
+    not executed when the model for the route changes.
+     ```app/routes/application.js
+    import { on } from '@ember/object/evented';
+    import Route from '@ember/routing/route';
+     export default Route.extend({
+      collectAnalytics: on('activate', function(){
+        collectAnalytics();
+      })
+    });
+    ```
+     @event activate
+    @since 1.9.0
+    @public
+  */
+
+  /**
+    This event is triggered when the router completely exits this
+    route. It is not executed when the model for the route changes.
+     ```app/routes/index.js
+    import { on } from '@ember/object/evented';
+    import Route from '@ember/routing/route';
+     export default Route.extend({
+      trackPageLeaveAnalytics: on('deactivate', function(){
+        trackPageLeaveAnalytics();
+      })
+    });
+    ```
+     @event deactivate
+    @since 1.9.0
+    @public
+  */
+
+  /**
+    This hook is executed when the router completely exits this route. It is
+    not executed when the model for the route changes.
+     @method deactivate
+    @param {Transition} transition
+    @since 1.0.0
+    @public
+  */
+  deactivate(_transition) {}
+
+  /**
+    This hook is executed when the router enters the route. It is not executed
+    when the model for the route changes.
+     @method activate
+    @param {Transition} transition
+    @since 1.0.0
+    @public
+  */
+  activate(_transition) {}
+
+  /**
+    Perform a synchronous transition into another route without attempting
+    to resolve promises, update the URL, or abort any currently active
+    asynchronous transitions (i.e. regular transitions caused by
+    `transitionTo` or URL changes).
+     This method is handy for performing intermediate transitions on the
+    way to a final destination route, and is called internally by the
+    default implementations of the `error` and `loading` handlers.
+     @method intermediateTransitionTo
+    @param {String} name the name of the route
+    @param {...Object} models the model(s) to be used while transitioning
+    to the route.
+    @since 1.2.0
+    @public
+   */
+  intermediateTransitionTo(...args) {
+    let [name, ...preparedArgs] = prefixRouteNameArg(this, args);
+    this._router.intermediateTransitionTo(name, ...preparedArgs);
+  }
+
+  /**
+    Refresh the model on this route and any child routes, firing the
+    `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
+    to how routes are entered when transitioning in from other route.
+    The current route params (e.g. `article_id`) will be passed in
+    to the respective model hooks, and if a different model is returned,
+    `setupController` and associated route hooks will re-fire as well.
+     An example usage of this method is re-querying the server for the
+    latest information using the same parameters as when the route
+    was first entered.
+     Note that this will cause `model` hooks to fire even on routes
+    that were provided a model object when the route was initially
+    entered.
+     @method refresh
+    @return {Transition} the transition object associated with this
+      attempted transition
+    @since 1.4.0
+    @public
+   */
+  refresh() {
+    return this._router._routerMicrolib.refresh(this);
+  }
+
+  /**
+    This hook is the entry point for router.js
+     @private
+    @method setup
+  */
+  setup(context, transition) {
+    let controllerName = this.controllerName || this.routeName;
+    let definedController = this.controllerFor(controllerName, true);
+    let controller = definedController ?? this.generateController(controllerName);
+
+    // SAFETY: Since `_qp` is protected we can't infer the type
+    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 propNames = queryParams.propertyNames;
+      addQueryParamsObservers(controller, propNames);
+      this.controller = controller;
+    }
+    let states = queryParams.states;
+    controller._qpDelegate = states.allowOverrides;
+    if (transition) {
+      // Update the model dep values used to calculate cache keys.
+      stashParamNames(this._router, transition[STATE_SYMBOL].routeInfos);
+      let cache = this._bucketCache;
+      let params = transition[PARAMS_SYMBOL];
+      let allParams = queryParams.propertyNames;
+      allParams.forEach(prop => {
+        let aQp = queryParams.map[prop];
+        aQp.values = params;
+        let cacheKey = calculateCacheKey(aQp.route.fullRouteName, aQp.parts, aQp.values);
+        let value = cache.lookup(cacheKey, prop, aQp.undecoratedDefaultValue);
+        set(controller, prop, value);
+      });
+      let qpValues = getQueryParamsFor(this, transition[STATE_SYMBOL]);
+      setProperties(controller, qpValues);
+    }
+    this.setupController(controller, context, transition);
+    if (this._environment.options.shouldRender) {
+      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.
+    flushAsyncObservers(false);
+  }
+
+  /*
+    Called when a query parameter for this route changes, regardless of whether the route
+    is currently part of the active route hierarchy. This will update the query parameter's
+    value in the cache so if this route becomes active, the cache value has been updated.
+  */
+  _qpChanged(prop, value, qp) {
+    if (!qp) {
+      return;
+    }
+
+    // Update model-dep cache
+    let cache = this._bucketCache;
+    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
+    `router.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(_transition) {}
+
+  /**
+    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';
+    import { service } from '@ember/service';
+     export default class PostsRoute extends Route {
+      @service router;
+       afterModel(posts, transition) {
+        if (posts.get('length') === 1) {
+          this.router.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
+   */
+
+  afterModel(_resolvedModel, _transition) {}
+
+  /**
+    A hook you can implement to optionally redirect to another route.
+     Calling `this.router.transitionTo` from inside of the `redirect` hook will
+    abort the current transition (into the route that has implemented `redirect`).
+     `redirect` and `afterModel` behave very similarly and are
+    called almost at the same time, but they have an important
+    distinction when calling `this.router.transitionTo` to a child route
+    of the current route. From `afterModel`, this new transition
+    invalidates the current transition, causing `beforeModel`,
+    `model`, and `afterModel` hooks to be called again. But the
+    same transition started from `redirect` does _not_ invalidate
+    the current transition. In other words, by the time the `redirect`
+    hook has been called, both the resolved model and the attempted
+    entry into this route are considered fully validated.
+     @method redirect
+    @param {Object} model the model for this route
+    @param {Transition} transition the transition object associated with the current transition
+    @since 1.0.0
+    @public
+  */
+  redirect(_model, _transition) {}
+
+  /**
+    Called when the context is changed by router.js.
+     @private
+    @method contextDidChange
+  */
+  contextDidChange() {
+    this.currentModel = this.context;
+  }
+
+  /**
+    A hook you can implement to convert the URL into the model for
+    this route.
+     ```app/router.js
+    // ...
+     Router.map(function() {
+      this.route('post', { path: '/posts/:post_id' });
+    });
+     export default Router;
+    ```
+     Note that for routes with dynamic segments, this hook is not always
+    executed. If the route is entered through a transition (e.g. when
+    using the `link-to` Handlebars helper or the `transitionTo` method
+    of routes), and a model context is already provided this hook
+    is not called.
+     A model context does not include a primitive string or number,
+    which does cause the model hook to be called.
+     Routes without dynamic segments will always execute the model hook.
+     ```javascript
+    // no dynamic segment, model hook always called
+    this.router.transitionTo('posts');
+     // model passed in, so model hook not called
+    thePost = store.findRecord('post', 1);
+    this.router.transitionTo('post', thePost);
+     // integer passed in, model hook is called
+    this.router.transitionTo('post', 1);
+     // model id passed in, model hook is called
+    // useful for forcing the hook to execute
+    thePost = store.findRecord('post', 1);
+    this.router.transitionTo('post', thePost.id);
+    ```
+     This hook follows the asynchronous/promise semantics
+    described in the documentation for `beforeModel`. In particular,
+    if a promise returned from `model` fails, the error will be
+    handled by the `error` hook on `Route`.
+     Note that the legacy behavior of automatically defining a model
+    hook when a dynamic segment ending in `_id` is present is
+    [deprecated](https://deprecations.emberjs.com/v5.x#toc_deprecate-implicit-route-model).
+    You should explicitly define a model hook whenever any segments are
+    present.
+     Example
+     ```app/routes/post.js
+    import Route from '@ember/routing/route';
+    import { service } from '@ember/service';
+     export default class PostRoute extends Route {
+      @service store;
+       model(params) {
+        return this.store.findRecord('post', params.post_id);
+      }
+    }
+    ```
+     @method model
+    @param {Object} params the parameters extracted from the URL
+    @param {Transition} transition
+    @return {any | Promise<any>} the model for this route. If
+      a promise is returned, the transition will pause until
+      the promise resolves, and the resolved value of the promise
+      will be used as the model for this route.
+    @since 1.0.0
+    @public
+  */
+  model(params, transition) {
+    let name, sawParams;
+    // 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) {
+        continue;
+      }
+      let match = prop.match(/^(.*)_id$/);
+      if (match !== null) {
+        name = match[1];
+      }
+      sawParams = true;
+    }
+    if (!name) {
+      if (sawParams) {
+        // SAFETY: This should be equivalent
+        return Object.assign({}, params);
+      } else {
+        if (transition.resolveIndex < 1) {
+          return;
+        }
+        // SAFETY: This should be correct, but TS is unable to infer this.
+        return transition[STATE_SYMBOL].routeInfos[transition.resolveIndex - 1].context;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+    @private
+    @method deserialize
+    @param {Object} params the parameters extracted from the URL
+    @param {Transition} transition
+    @return {any | Promise<any>} the model for this route.
+     Router.js hook.
+   */
+  deserialize(_params, transition) {
+    return this.model(this._paramsFor(this.routeName, _params), transition);
+  }
+
+  /**
+    A hook you can use to setup the controller 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, the `setupController` hook sets the `model` property of
+    the controller to the specified `model` when it is not `undefined`.
+     If you implement the `setupController` hook in your Route, it will
+    prevent this default behavior. If you want to preserve that behavior
+    when implementing your `setupController` function, make sure to call
+    `super`:
+     ```app/routes/photos.js
+    import Route from '@ember/routing/route';
+    import { service } from '@ember/service';
+     export default class PhotosRoute extends Route {
+      @service store;
+       model() {
+        return this.store.findAll('photo');
+      }
+       setupController(controller, model) {
+        super.setupController(controller, model);
+         this.controllerFor('application').set('showingPhotos', true);
+      }
+    }
+    ```
+     The provided controller will be one resolved based on the name
+    of this route.
+     If no explicit controller is defined, Ember will automatically create one.
+     As an example, consider the router:
+     ```app/router.js
+    // ...
+     Router.map(function() {
+      this.route('post', { path: '/posts/:post_id' });
+    });
+     export default Router;
+    ```
+     If you have defined a file for the post controller,
+    the framework will use it.
+    If it is not defined, a basic `Controller` instance would be used.
+     @example Behavior of a basic Controller
+     ```app/routes/post.js
+    import Route from '@ember/routing/route';
+     export default class PostRoute extends Route {
+      setupController(controller, model) {
+        controller.set('model', model);
+      }
+    });
+    ```
+     @method setupController
+    @param {Controller} controller instance
+    @param {Object} model
+    @param {Transition} [transition]
+    @since 1.0.0
+    @public
+  */
+  setupController(controller, context, _transition) {
+    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 | undefined}
+    @since 1.0.0
+    @public
+  */
+
+  controllerFor(name, _skipAssert = false) {
+    let owner = getOwner(this);
+    let route = owner.lookup(`route:${name}`);
+    if (route && route.controllerName) {
+      name = route.controllerName;
+    }
+    let controller = owner.lookup(`controller:${name}`);
+    return controller;
+  }
+
+  /**
+    Generates a controller for a route.
+     Example
+     ```app/routes/post.js
+    import Route from '@ember/routing/route';
+     export default class Post extends Route {
+      setupController(controller, post) {
+        super.setupController(controller, post);
+         this.generateController('posts');
+      }
+    }
+    ```
+     @method generateController
+    @param {String} name the name of the controller
+    @private
+  */
+  generateController(name) {
+    let owner = getOwner(this);
+    return generateController(owner, name);
+  }
+
+  /**
+    Returns the resolved model of a parent (or any ancestor) route
+    in a route hierarchy.  During a transition, all routes
+    must resolve a model object, and if a route
+    needs access to a parent route's model in order to
+    resolve a model (or just reuse the model from a parent),
+    it can call `this.modelFor(theNameOfParentRoute)` to
+    retrieve it. If the ancestor route's model was a promise,
+    its resolved result is returned.
+     Example
+     ```app/router.js
+    // ...
+     Router.map(function() {
+      this.route('post', { path: '/posts/:post_id' }, function() {
+        this.route('comments');
+      });
+    });
+     export default Router;
+    ```
+     ```app/routes/post/comments.js
+    import Route from '@ember/routing/route';
+     export default class PostCommentsRoute extends Route {
+      model() {
+        let post = this.modelFor('post');
+         return post.comments;
+      }
+    }
+    ```
+     @method modelFor
+    @param {String} name the name of the route
+    @return {Object} the model object
+    @since 1.0.0
+    @public
+  */
+  modelFor(_name) {
+    let name;
+    let owner = getOwner(this);
+    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.
+    if (owner.routable && transition !== undefined) {
+      name = getEngineRouteName(owner, _name);
+    } else {
+      name = _name;
+    }
+    let route = owner.lookup(`route:${name}`);
+    // If we are mid-transition, we want to try and look up
+    // resolved parent contexts on the current transitionEvent.
+    if (transition !== undefined && transition !== null) {
+      let modelLookupName = route && route.routeName || name;
+      if (Object.prototype.hasOwnProperty.call(transition.resolvedModels, modelLookupName)) {
+        return transition.resolvedModels[modelLookupName];
+      }
+    }
+    return route?.currentModel;
+  }
+  [RENDER_STATE] = undefined;
+
+  /**
+    `this[RENDER]` is used to set up the rendering option for the outlet state.
+    @method this[RENDER]
+    @private
+   */
+  [RENDER]() {
+    this[RENDER_STATE] = buildRenderState(this);
+    once(this._router, '_setOutlets');
+  }
+  willDestroy() {
+    this.teardownViews();
+  }
+
+  /**
+    @private
+     @method teardownViews
+  */
+  teardownViews() {
+    if (this[RENDER_STATE]) {
+      this[RENDER_STATE] = undefined;
+      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() {}
+  _paramsFor(routeName, params) {
+    let transition = this._router._routerMicrolib.activeTransition;
+    if (transition !== undefined) {
+      return this.paramsFor(routeName);
+    }
+    return params;
+  }
+
+  /** @deprecated Manually define your own store, such as with `@service store` */
+  get _store() {
+    const owner = getOwner(this);
+    this.routeName;
+    return {
+      find(name, value) {
+        let modelClass = owner.factoryFor(`model:${name}`);
+        if (!modelClass) {
+          return;
+        }
+        modelClass = modelClass.class;
+        return modelClass.find(value);
+      }
+    };
+  }
+
+  /**
+    @private
+    @property _qp
+    */
+  static {
+    decorateMethodV2(this.prototype, "_store", [computed]);
+  }
+  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) {
+      // 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 = undefined;
+      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,
+        // provided later when stashNames is called if 'model' scope
+        values: null,
+        // provided later when setup is called. no idea why.
+        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);
+        }
+      }
+    };
+  }
+
+  // Set in reopen
+  static {
+    decorateMethodV2(this.prototype, "_qp", [computed]);
+  }
+  /**
+    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
+  */
+  // Set with reopen to override parent behavior
+}
+function getRenderState(route) {
+  return route[RENDER_STATE];
+}
+function buildRenderState(route) {
+  let owner = getOwner(route);
+  let name = route.routeName;
+  let controller = owner.lookup(`controller:${route.controllerName || name}`);
+  let model = route.currentModel;
+  let templateFactoryOrComponent = owner.lookup(`template:${route.templateName || name}`);
+
+  // Now we support either a component or a template to be returned by this
+  // resolver call, but if it's a `TemplateFactory`, we need to instantiate
+  // it into a `Template`, since that's what `RenderState` wants. We can't
+  // easily change it, it's intimate API used by @ember/test-helpers and the
+  // like. We could compatibly allow `Template` | `TemplateFactory`, and that's
+  // what it used to do but we _just_ went through deprecations to get that
+  // removed. It's also not ideal since once you mix the two types, they are
+  // not exactly easy to tell apart.
+  //
+  // It may also be tempting to just normalize `Template` into `RouteTemplate`
+  // here, and we could. However, this is not the only entrypoint where this
+  // `RenderState` is made – @ember/test-helpers punches through an impressive
+  // amount of private API to set it directly, and this feature would also be
+  // useful for them. So, even if we had normalized here, we'd still have to
+  // check and do that again during render anyway.
+  let template;
+  if (templateFactoryOrComponent) {
+    if (hasInternalComponentManager(templateFactoryOrComponent)) {
+      template = templateFactoryOrComponent;
+    } else {
+      template = templateFactoryOrComponent(owner);
+    }
+  } else {
+    // default `{{outlet}}`
+    template = route._topLevelViewTemplate(owner);
+  }
+  let render = {
+    owner,
+    name,
+    controller,
+    model,
+    template
+  };
+  return render;
+}
+function getFullQueryParams(router, state) {
+  if (state.fullQueryParams) {
+    return state.fullQueryParams;
+  }
+  let haveAllRouteInfosResolved = state.routeInfos.every(routeInfo => routeInfo.route);
+  let 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
+  // we wait until all routes have resolved prior to caching query params state
+  if (haveAllRouteInfosResolved) {
+    state.fullQueryParams = fullQueryParamsState;
+  }
+  return fullQueryParamsState;
+}
+function getQueryParamsFor(route, state) {
+  state.queryParamsFor = state.queryParamsFor || {};
+  let name = route.fullRouteName;
+  let existing = 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.
+  // SAFETY: Since `_qp` is protected we can't infer the type
+  let qps = get(route, '_qp').qps;
+  for (let qp of qps) {
+    // Put deserialized qp on params hash.
+    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 A(value.slice());
+  }
+  return value;
+}
+
+/*
+  Merges all query parameters from a controller with those from
+  a route, returning a new object and avoiding any mutations to
+  the existing objects.
+*/
+function mergeEachQueryParams(controllerQP, routeQP) {
+  let qps = {};
+  let keysAlreadyMergedOrSkippable = {
+    defaultValue: true,
+    type: true,
+    scope: true,
+    as: true
+  };
+
+  // first loop over all controller qps, merging them with any matching route qps
+  // into a new empty object to avoid mutating.
+  for (let cqpName in controllerQP) {
+    if (!Object.prototype.hasOwnProperty.call(controllerQP, cqpName)) {
+      continue;
+    }
+    qps[cqpName] = {
+      ...controllerQP[cqpName],
+      ...routeQP[cqpName]
+    };
+
+    // allows us to skip this QP when we check route QPs.
+    keysAlreadyMergedOrSkippable[cqpName] = true;
+  }
+
+  // loop over all route qps, skipping those that were merged in the first pass
+  // because they also appear in controller qps
+  for (let rqpName in routeQP) {
+    if (!Object.prototype.hasOwnProperty.call(routeQP, rqpName) || keysAlreadyMergedOrSkippable[rqpName]) {
+      continue;
+    }
+    qps[rqpName] = {
+      ...routeQP[rqpName],
+      ...controllerQP[rqpName]
+    };
+  }
+  return qps;
+}
+function addQueryParamsObservers(controller, propNames) {
+  propNames.forEach(prop => {
+    if (descriptorForProperty(controller, prop) === undefined) {
+      let desc = lookupDescriptor(controller, prop);
+      if (desc !== null && (typeof desc.get === 'function' || typeof desc.set === 'function')) {
+        defineProperty(controller, prop, dependentKeyCompat({
+          get: desc.get,
+          set: desc.set
+        }));
+      }
+    }
+    addObserver(controller, `${prop}.[]`, controller, controller._qpChanged, false);
+  });
+}
+function getEngineRouteName(engine, routeName) {
+  if (engine.routable) {
+    let prefix = engine.mountPoint;
+    if (routeName === 'application') {
+      return prefix;
+    } else {
+      return `${prefix}.${routeName}`;
+    }
+  }
+  return routeName;
+}
+const defaultSerialize = Route.prototype.serialize;
+function hasDefaultSerialize(route) {
+  return route.serialize === defaultSerialize;
+}
+
+// Set these here so they can be overridden with extend
+Route.reopen({
+  mergedProperties: ['queryParams'],
+  queryParams: {},
+  templateName: null,
+  controllerName: null,
+  send(...args) {
+    if (this._router && this._router._routerMicrolib || !isTesting()) {
+      this._router.send(...args);
+    } else {
+      let name = args.shift();
+      let action = this.actions[name];
+      if (action) {
+        return action.apply(this, args);
+      }
+    }
+  },
+  /**
+    The controller associated with this route.
+     Example
+     ```app/routes/form.js
+    import Route from '@ember/routing/route';
+    import { action } from '@ember/object';
+     export default class FormRoute extends Route {
+      @action
+      willTransition(transition) {
+        if (this.controller.get('userHasEnteredData') &&
+            !confirm('Are you sure you want to abandon progress?')) {
+          transition.abort();
+        } else {
+          // Bubble the `willTransition` action so that
+          // parent routes can decide whether or not to abort.
+          return true;
+        }
+      }
+    }
+    ```
+     @property controller
+    @type Controller
+    @since 1.6.0
+    @public
+  */
+
+  actions: {
+    /**
+    This action is called when one or more query params have changed. Bubbles.
+     @method queryParamsDidChange
+    @param changed {Object} Keys are names of query params that have changed.
+    @param totalPresent {Object} Keys are names of query params that are currently set.
+    @param removed {Object} Keys are names of query params that have been removed.
+    @returns {boolean}
+    @private
+    */
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    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 change of totalChanged) {
+        let qp = qpMap[change];
+        if (qp) {
+          let options = this._optionsForQueryParam(qp);
+          if (get(options, 'refreshModel') && this._router.currentState) {
+            this.refresh();
+            break;
+          }
+        }
+      }
+      return true;
+    },
+    finalizeQueryParamChange(params,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    finalParams, transition) {
+      if (this.fullRouteName !== 'application') {
+        return true;
+      }
+
+      // Transition object is absent for intermediate transitions.
+      if (!transition) {
+        return;
+      }
+      let routeInfos = transition[STATE_SYMBOL].routeInfos;
+      let router = this._router;
+      let qpMeta = router._queryParamsFor(routeInfos);
+      let changes = router._qpUpdates;
+      let qpUpdated = false;
+      let replaceUrl;
+      stashParamNames(router, routeInfos);
+      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;
+        let svalue;
+        if (changes.has(qp.urlKey)) {
+          // Value updated in/before setupController
+          value = get(controller, qp.prop);
+          svalue = route.serializeQueryParam(value, qp.urlKey, qp.type);
+        } else {
+          if (presentKey) {
+            svalue = params[presentKey];
+            if (svalue !== undefined) {
+              value = route.deserializeQueryParam(svalue, qp.urlKey, qp.type);
+            }
+          } else {
+            // No QP provided; use default value.
+            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;
+        let thisQueryParamChanged = svalue !== qp.serializedValue;
+        if (thisQueryParamChanged) {
+          if (transition.queryParamsOnly && replaceUrl !== false) {
+            let options = route._optionsForQueryParam(qp);
+            let replaceConfigValue = get(options, 'replace');
+            if (replaceConfigValue) {
+              replaceUrl = true;
+            } else if (replaceConfigValue === false) {
+              // Explicit pushState wins over any other replaceStates.
+              replaceUrl = false;
+            }
+          }
+          set(controller, qp.prop, value);
+          qpUpdated = true;
+        }
+
+        // Stash current serialized value of controller.
+        qp.serializedValue = svalue;
+        let thisQueryParamHasDefaultValue = qp.serializedDefaultValue === svalue;
+        if (!thisQueryParamHasDefaultValue) {
+          finalParams.push({
+            value: svalue,
+            visible: true,
+            key: presentKey || qp.urlKey
+          });
+        }
+      }
+
+      // Some QPs have been updated, and those changes need to be propogated
+      // immediately. Eventually, we should work on making this async somehow.
+      if (qpUpdated === true) {
+        flushAsyncObservers(false);
+      }
+      if (replaceUrl) {
+        transition.method('replace');
+      }
+      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');
+      });
+      router._qpUpdates.clear();
+      return;
+    }
+  }
+});
+
+export { Route as default, defaultSerialize, getFullQueryParams, getRenderState, hasDefaultSerialize };