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

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.3.0-beta.1
+ * @version   4.4.0-alpha.3
  */

package/dist/packages/@ember/-internals/container/index.js

@@ -187,8 +187,6 @@ class Container {
     @public
    @method factoryFor
    @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
 
@@ -199,7 +197,9 @@ class Container {
     }
 
     let normalizedName = this.registry.normalize(fullName);
-    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
+    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)); // TODO: This needs to return a Factory to be compatible with Owner.
+    // We should correctly the types so that this cast is not necessary.
+
     return factoryFor(this, normalizedName, fullName);
   }
 

package/dist/packages/@ember/-internals/glimmer/index.js

@@ -9,8 +9,9 @@ import { untrack, consumeTag, createCache, getValue, tagFor, beginUntrackFrame,
 import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, set, _getProp, _setProp } from '@ember/-internals/metal';
 import { action } from '@ember/object';
 import { hasDOM } from '@ember/-internals/browser-environment';
-import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
+import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, EventDispatcher, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
 import { getEngineParent } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 import { flaggedInstrument, _instrumentStart } from '@ember/instrumentation';
 import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
@@ -1099,11 +1100,13 @@ class LinkTo extends InternalComponent {
   }
 
   get isEngine() {
-    return getEngineParent(this.owner) !== undefined;
+    let owner = this.owner;
+    return owner instanceof EngineInstance && getEngineParent(owner) !== undefined;
   }
 
   get engineMountPoint() {
-    return this.owner.mountPoint;
+    let owner = this.owner;
+    return owner instanceof EngineInstance ? owner.mountPoint : undefined;
   }
 
   classFor(state) {
@@ -1960,13 +1963,12 @@ function makeClosureAction(context, target, action$$1, processArgs, debugKey) {
   let self;
   let fn$$1;
   assert(`Action passed is null or undefined in (action) from ${target}.`, action$$1 !== undefined && action$$1 !== null);
-  let typeofAction = typeof action$$1;
 
-  if (typeofAction === 'string') {
+  if (typeof action$$1 === 'string') {
     self = target;
     fn$$1 = target.actions && target.actions[action$$1];
     assert(`An action named '${action$$1}' was not found in ${target}`, Boolean(fn$$1));
-  } else if (typeofAction === 'function') {
+  } else if (typeof action$$1 === 'function') {
     self = context;
     fn$$1 = action$$1;
   } else {
@@ -3165,6 +3167,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
 
       if (owner.lookup('-environment:main').isInteractive) {
         this.__dispatcher = owner.lookup('event_dispatcher:main');
+        assert('Expected dispatcher to be an EventDispatcher', this.__dispatcher instanceof EventDispatcher);
       } else {
         // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
         this.__dispatcher = null;
@@ -3787,11 +3790,9 @@ class OutletComponentManager {
       let currentOwner = valueForRef(currentStateRef).render.owner;
 
       if (parentOwner && parentOwner !== currentOwner) {
-        let engine = currentOwner;
-        assert('invalid engine: missing mountPoint', typeof currentOwner.mountPoint === 'string');
-        assert('invalid engine: missing routable', currentOwner.routable === true);
-        let mountPoint = engine.mountPoint;
-        state.engine = engine;
+        assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance);
+        let mountPoint = currentOwner.mountPoint;
+        state.engine = currentOwner;
         state.engineBucket = {
           mountPoint
         };
@@ -4575,7 +4576,7 @@ var disallowDynamicResolution = internalHelper(({
   assert('[BUG] expecting a string literal for the `original` argument', typeof original === 'string');
   return createComputeRef(() => {
     let nameOrValue = valueForRef(nameOrValueRef);
-    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them to the ${type} keyword. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
+    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them directly. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
     return nameOrValue;
   });
 });
@@ -4933,6 +4934,25 @@ var unbound = internalHelper(({
   return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
 });
 
+/**
+@module ember
+*/
+internalHelper(() => {
+  return createConstRef(uniqueId$1(), 'unique-id');
+}); // From https://gist.github.com/selfish/fef2c0ba6cdfe07af76e64cecd74888b
+//
+// This code should be reasonably fast, and provide a unique value every time
+// it's called, which is what we need here. It produces a string formatted as a
+// standard UUID, which avoids accidentally turning Ember-specific
+// implementation details into an intimate API.
+
+function uniqueId$1() {
+  // @ts-expect-error this one-liner abuses weird JavaScript semantics that
+  // TypeScript (legitimately) doesn't like, but they're nonetheless valid and
+  // specced.
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, a => (a ^ Math.random() * 16 >> a / 4).toString(16));
+}
+
 const MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
 const POINTER_EVENT_TYPE_REGEX = /^click|mouse|touch/;
 
@@ -5165,6 +5185,7 @@ class ActionModifierManager {
 
   ensureEventSetup(actionState) {
     let dispatcher = actionState.owner.lookup('event_dispatcher:main');
+    assert('Expected dispatcher to be an EventDispatcher', dispatcher instanceof EventDispatcher);
     dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.setupHandlerForEmberEvent(actionState.eventName);
   }
 
@@ -5218,6 +5239,7 @@ class MountManager {
     // mount is a runtime helper, this shouldn't use dynamic layout
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
+    assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance);
     let engine = owner.buildChildEngineInstance(name);
     engine.boot();
     let applicationFactory = engine.factoryFor(`controller:application`);
@@ -5430,28 +5452,17 @@ const mountHelper = internalHelper((args, owner) => {
   Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
 
   @method outlet
-  @param {String} [name]
   @for Ember.Templates.helpers
   @public
 */
 
-const outletHelper = internalHelper((args, owner, scope) => {
+const outletHelper = internalHelper((_args, owner, scope) => {
   assert('Expected owner to be present, {{outlet}} requires an owner', owner);
   assert('Expected dynamic scope to be present. You may have attempted to use the {{outlet}} keyword dynamically. This keyword cannot be used dynamically.', scope);
-  let nameRef;
-
-  if (args.positional.length === 0) {
-    nameRef = createPrimitiveRef('main');
-  } else {
-    let maybeNameRef = args.positional[0];
-    assert('Expected at least one positional arg', maybeNameRef);
-    nameRef = maybeNameRef;
-  }
-
   let outletRef = createComputeRef(() => {
     let state = valueForRef(scope.get('outletState'));
     let outlets = state !== undefined ? state.outlets : undefined;
-    return outlets !== undefined ? outlets[valueForRef(nameRef)] : undefined;
+    return outlets !== undefined ? outlets.main : undefined;
   });
   let lastState = null;
   let definition = null;
@@ -5541,9 +5552,9 @@ function instrumentationPayload$1(name) {
   };
 }
 
-function componentFor(name, owner, options) {
+function componentFor(name, owner) {
   let fullName = `component:${name}`;
-  return owner.factoryFor(fullName, options) || null;
+  return owner.factoryFor(fullName) || null;
 }
 
 function layoutFor(name, owner, options) {
@@ -5552,7 +5563,7 @@ function layoutFor(name, owner, options) {
 }
 
 function lookupComponentPair(owner, name, options) {
-  let component = componentFor(name, owner, options);
+  let component = componentFor(name, owner);
 
   if (component !== null && component.class !== undefined) {
     let layout = getComponentTemplate(component.class);
@@ -5613,6 +5624,7 @@ const BUILTIN_HELPERS = Object.assign(Object.assign({}, BUILTIN_KEYWORD_HELPERS)
   get: get$1,
   hash
 });
+
 const BUILTIN_KEYWORD_MODIFIERS = {
   action: actionModifier
 };
@@ -6329,7 +6341,9 @@ class OutletView {
       target = selector;
     }
 
-    let renderer = this.owner.lookup('renderer:-dom');
+    let renderer = this.owner.lookup('renderer:-dom'); // SAFETY: It's not clear that this cast is safe.
+    // The types for appendOutletView may be incorrect or this is a potential bug.
+
     schedule('render', renderer, 'appendOutletView', this, target);
   }
 
@@ -6391,6 +6405,18 @@ function setupEngineRegistry(registry) {
   }
 }
 
+/**
+   Associate a class with a component manager (an object that is responsible for
+   coordinating the lifecycle events that occurs when invoking, rendering and
+   re-rendering a component).
+
+   @method setComponentManager
+   @param {Function} factory a function to create the owner for an object
+   @param {Object} obj the object to associate with the componetn manager
+   @return {Object} the same object passed in
+   @public
+  */
+
 function setComponentManager$1(manager, obj) {
   return setComponentManager(manager, obj);
 }

package/dist/packages/@ember/-internals/metal/index.js

@@ -145,7 +145,7 @@ function sendEvent(obj, eventName, params, actions, _meta) {
   return true;
 }
 /**
-  @private
+  @public
   @method hasListeners
   @static
   @for @ember/object/events
@@ -1782,20 +1782,20 @@ function get(obj, keyName) {
   return isPath(keyName) ? _getPath(obj, keyName) : _getProp(obj, keyName);
 }
 function _getProp(obj, keyName) {
-  let type = typeof obj;
-  let isObject$$1 = type === 'object';
-  let isFunction = type === 'function';
-  let isObjectLike = isObject$$1 || isFunction;
+  if (obj == null) {
+    return;
+  }
+
   let value;
 
-  if (isObjectLike) {
+  if (typeof obj === 'object' || typeof obj === 'function') {
     if (DEBUG) {
       value = getPossibleMandatoryProxyValue(obj, keyName);
     } else {
       value = obj[keyName];
     }
 
-    if (value === undefined && isObject$$1 && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
+    if (value === undefined && typeof obj === 'object' && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
       value = obj.unknownProperty(keyName);
     }
 
@@ -1809,13 +1809,13 @@ function _getProp(obj, keyName) {
       }
     }
   } else {
+    // SAFETY: It should be ok to access properties on any non-nullish value
     value = obj[keyName];
   }
 
   return value;
 }
-function _getPath(root, path) {
-  let obj = root;
+function _getPath(obj, path) {
   let parts = typeof path === 'string' ? path.split('.') : path;
 
   for (let part of parts) {
@@ -1838,12 +1838,12 @@ _getProp({}, 'a');
 _getProp({}, 1);
 
 _getProp({
-  unkonwnProperty() {}
+  unknownProperty() {}
 
 }, 'a');
 
 _getProp({
-  unkonwnProperty() {}
+  unknownProperty() {}
 
 }, 1);
 
@@ -2125,7 +2125,6 @@ function eachProxyArrayDidChange(array, idx, removedCnt, addedCnt) {
   confusing.
 
   ```javascript
-  isNone();              // true
   isNone(null);          // true
   isNone(undefined);     // true
   isNone('');            // false
@@ -2159,7 +2158,6 @@ function isNone(obj) {
   to check emptiness.
 
   ```javascript
-  isEmpty();                 // true
   isEmpty(null);             // true
   isEmpty(undefined);        // true
   isEmpty('');               // true
@@ -2183,31 +2181,21 @@ function isNone(obj) {
 */
 
 function isEmpty(obj) {
-  let none = obj === null || obj === undefined;
-
-  if (none) {
-    return none;
+  if (obj === null || obj === undefined) {
+    return true;
   }
 
   if (typeof obj.unknownProperty !== 'function' && typeof obj.size === 'number') {
     return !obj.size;
   }
 
-  let objectType = typeof obj;
-
-  if (objectType === 'object') {
+  if (typeof obj === 'object') {
     let size = get(obj, 'size');
 
     if (typeof size === 'number') {
       return !size;
     }
-  }
-
-  if (typeof obj.length === 'number' && objectType !== 'function') {
-    return !obj.length;
-  }
 
-  if (objectType === 'object') {
     let length = get(obj, 'length');
 
     if (typeof length === 'number') {
@@ -2215,6 +2203,10 @@ function isEmpty(obj) {
     }
   }
 
+  if (typeof obj.length === 'number' && typeof obj !== 'function') {
+    return !obj.length;
+  }
+
   return false;
 }
 
@@ -2228,7 +2220,6 @@ function isEmpty(obj) {
   ```javascript
   import { isBlank } from '@ember/utils';
 
-  isBlank();                // true
   isBlank(null);            // true
   isBlank(undefined);       // true
   isBlank('');              // true
@@ -2262,7 +2253,6 @@ function isBlank(obj) {
   A value is present if it not `isBlank`.
 
   ```javascript
-  isPresent();                // false
   isPresent(null);            // false
   isPresent(undefined);       // false
   isPresent('');              // false

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

@@ -124,7 +124,7 @@ export default class HashLocation extends EmberObject {
   onUpdateURL(callback) {
     this._removeEventListener();
 
-    this._hashchangeHandler = bind(this, function () {
+    this._hashchangeHandler = bind(this, function (_event) {
       let path = this.getURL();
 
       if (this.lastSetURL === path) {

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

@@ -13,6 +13,7 @@ import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 import { consumeTag, tagFor } from '@glimmer/validator';
+import EmberRouter from '../system/router';
 import { extractRouteArgs, resemblesURL, shallowEqual } from '../utils';
 const ROUTER = symbol('ROUTER');
 
@@ -27,6 +28,55 @@ function cleanURL(url, rootURL) {
 class RouterService extends Service.extend(Evented) {
   constructor() {
     super(...arguments);
+    /**
+      You can register a listener for events emitted by this service with `.on()`:
+             ```app/routes/contact-form.js
+      import Route from '@ember/routing';
+      import { service } from '@ember/service';
+             export default class extends Route {
+        @service router;
+               activate() {
+          this.router.on('routeWillChange', (transition) => {
+            if (!transition.to.find(route => route.name === this.routeName)) {
+              alert("Please save or cancel your changes.");
+              transition.abort();
+            }
+          })
+        }
+      }
+      ```
+             @method on
+      @param {String} eventName
+      @param {Function} callback
+      @public
+    */
+
+    /**
+      You can unregister a listener for events emitted by this service with `.off()`:
+             ```app/routes/contact-form.js
+      import Route from '@ember/routing';
+      import { service } from '@ember/service';
+             export default class extends Route {
+        @service router;
+               callback = (transition) =>  {
+          if (!transition.to.find(route => route.name === this.routeName)) {
+            alert("Please save or cancel your changes.");
+            transition.abort();
+          }
+        };
+               activate() {
+          this.router.on('routeWillChange', this.callback);
+        }
+               deactivate() {
+          this.router.off('routeWillChange', this.callback);
+      }
+      ```
+             @method off
+      @param {String} eventName
+      @param {Function} callback
+      @public
+    */
+
     /**
       The `routeWillChange` event is fired at the beginning of any
       attempted transition with a `Transition` object as the sole
@@ -39,9 +89,8 @@ class RouterService extends Service.extend(Evented) {
       import { service } from '@ember/service';
              export default class extends Route {
         @service router;
-               constructor() {
-          super(...arguments);
-                 this.router.on('routeWillChange', (transition) => {
+               activate() {
+          this.router.on('routeWillChange', (transition) => {
             if (!transition.to.find(route => route.name === this.routeName)) {
               alert("Please save or cancel your changes.");
               transition.abort();
@@ -66,9 +115,8 @@ class RouterService extends Service.extend(Evented) {
       import { service } from '@ember/service';
              export default class extends Route {
         @service router;
-               constructor() {
-          super(...arguments);
-                 this.router.on('routeDidChange', (transition) => {
+               activate() {
+          this.router.on('routeDidChange', (transition) => {
             ga.send('pageView', {
               current: transition.to.name,
               from: transition.from.name
@@ -133,6 +181,7 @@ class RouterService extends Service.extend(Evented) {
     let owner = getOwner(this);
     assert('RouterService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
+    assert('ROUTER SERVICE BUG: Expected router to be an instance of EmberRouter', router instanceof EmberRouter);
     return this[ROUTER] = router;
   }
 
@@ -195,7 +244,6 @@ class RouterService extends Service.extend(Evented) {
 
     let transition = this._router._doTransition(routeName, models, queryParams, true);
 
-    transition['_keepDefaultQueryParamValues'] = true;
     return transition;
   }
   /**
@@ -366,19 +414,26 @@ class RouterService extends Service.extend(Evented) {
     let hasQueryParams = Object.keys(queryParams).length > 0;
 
     if (hasQueryParams) {
-      queryParams = Object.assign({}, queryParams);
-
-      this._router._prepareQueryParams( // UNSAFE: casting `routeName as string` here encodes the existing
+      // UNSAFE: casting `routeName as string` here encodes the existing
       // assumption but may be wrong: `extractRouteArgs` correctly returns it
       // as `string | undefined`. There may be bugs if `_prepareQueryParams`
       // does not correctly account for `undefined` values for `routeName`.
       //  Spoilers: under the hood this currently uses router.js APIs which
       // *do not* account for this being `undefined`.
-      routeName, models, queryParams, true
+      let targetRouteName = routeName;
+      queryParams = Object.assign({}, queryParams);
+
+      this._router._prepareQueryParams(targetRouteName, models, queryParams, true
+      /* fromRouterService */
+      );
+
+      let currentQueryParams = Object.assign({}, routerMicrolib.state.queryParams);
+
+      this._router._prepareQueryParams(targetRouteName, models, currentQueryParams, true
       /* fromRouterService */
       );
 
-      return shallowEqual(queryParams, routerMicrolib.state.queryParams);
+      return shallowEqual(queryParams, currentQueryParams);
     }
 
     return true;

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

@@ -6,6 +6,7 @@ import { symbol } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
+import EmberRouter from '../system/router';
 const ROUTER = symbol('ROUTER');
 /**
   The Routing service is used by LinkTo, and provides facilities for
@@ -29,6 +30,7 @@ export default class RoutingService extends Service {
     let owner = getOwner(this);
     assert('RoutingService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
+    assert('ROUTING SERVICE BUG: Expected router to be an instance of EmberRouter', router instanceof EmberRouter);
     router.setupRouter();
     return this[ROUTER] = router;
   }

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

@@ -1,5 +1,6 @@
 import { get } from '@ember/-internals/metal';
-import { info } from '@ember/debug';
+import Controller from '@ember/controller';
+import { assert, info } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 /**
 @module ember
@@ -39,6 +40,7 @@ export default function generateController(owner, controllerName) {
   generateControllerFactory(owner, controllerName);
   let fullName = `controller:${controllerName}`;
   let instance = owner.lookup(fullName);
+  assert('Expected an instance of controller', instance instanceof Controller);
 
   if (DEBUG) {
     if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {

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

@@ -9,27 +9,31 @@ var __decorate = this && this.__decorate || function (decorators, target, key, d
 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 { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, ActionHandler, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { isProxy, lookupDescriptor, symbol } from '@ember/-internals/utils';
+import Controller from '@ember/controller';
 import { assert, info, isTesting } from '@ember/debug';
+import EngineInstance from '@ember/engine/instance';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import { PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
 import { calculateCacheKey, deprecateTransitionMethods, normalizeControllerQueryParams, prefixRouteNameArg, stashParamNames } from '../utils';
 import generateController from './generate_controller';
+import EmberRouter from './router';
 export const ROUTE_CONNECTIONS = new WeakMap();
 const RENDER = symbol('render');
 
 class Route extends EmberObject.extend(ActionHandler, Evented) {
   constructor(owner) {
-    super(...arguments);
+    super(owner);
     this.context = {};
 
     if (owner) {
       let router = owner.lookup('router:main');
       let bucketCache = owner.lookup(P`-bucket-cache:main`);
-      assert('ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!', router && bucketCache);
+      assert('ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!', router instanceof EmberRouter && bucketCache instanceof BucketCache);
       this._router = router;
       this._bucketCache = bucketCache;
       this._topLevelViewTemplate = owner.lookup('template:-outlet');
@@ -110,7 +114,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   _setRouteName(name) {
     this.routeName = name;
     let owner = getOwner(this);
-    assert('Route is unexpectedly missing an owner', owner);
+    assert('Expected route to have EngineInstance as owner', owner instanceof EngineInstance);
     this.fullRouteName = getEngineRouteName(owner, name);
   }
   /**
@@ -836,8 +840,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       } else {
         if (transition.resolveIndex < 1) {
           return;
-        } // SAFETY: These return types should be equivalent but router.js doesn't have enough
-        // generics to infer it.
+        } // SAFETY: This should be correct, but TS is unable to infer this.
 
 
         return transition[STATE_SYMBOL].routeInfos[transition.resolveIndex - 1].context;
@@ -944,6 +947,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     //   passed a model to skip the assertion.
 
     assert(`The controller named '${name}' could not be found. Make sure that this route exists and has already been entered at least once. If you are accessing a controller not associated with a route, make sure the controller class is explicitly defined.`, controller !== undefined || _skipAssert === true);
+    assert(`Expected controller:${name} to be an instance of Controller`, controller === undefined || controller instanceof Controller);
     return controller;
   }
   /**
@@ -1008,7 +1012,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   modelFor(_name) {
     let name;
     let owner = getOwner(this);
-    assert('Route is unexpectedly missing an owner', owner);
+    assert('Expected router owner to be an EngineInstance', owner instanceof EngineInstance);
     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.
 
@@ -1136,10 +1140,11 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
 
     if (controller) {
-      // the developer has authored a controller class in their application for
+      assert('Expected an instance of controller', controller instanceof 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);
@@ -1299,7 +1304,7 @@ function buildRenderOptions(route, nameOrOptions, options) {
   let owner = getOwner(route);
   assert('Route is unexpectedly missing an owner', owner);
   let name, templateName, into, outlet, model;
-  let controller = undefined;
+  let controller;
 
   if (options) {
     into = options.into && options.into.replace(/\//g, '.');
@@ -1332,6 +1337,8 @@ function buildRenderOptions(route, nameOrOptions, options) {
     assert(`You passed \`controller: '${controllerName}'\` into the \`render\` method, but no such controller could be found.`, isDefaultRender || controller !== undefined);
   }
 
+  assert('Expected an instance of controller', controller instanceof Controller);
+
   if (model === undefined) {
     model = route.currentModel;
   } else {
@@ -1656,7 +1663,7 @@ Route.reopen({
         qp.serializedValue = svalue;
         let thisQueryParamHasDefaultValue = qp.serializedDefaultValue === svalue;
 
-        if (!thisQueryParamHasDefaultValue || transition._keepDefaultQueryParamValues) {
+        if (!thisQueryParamHasDefaultValue) {
           finalParams.push({
             value: svalue,
             visible: true,