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

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
@@ -1755,9 +1755,6 @@ function isPath(path) {
   return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
 }
 
-/**
-@module @ember/object
-*/
 const PROXY_CONTENT = symbol('PROXY_CONTENT');
 let getPossibleMandatoryProxyValue;
 
@@ -1782,20 +1779,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 +1806,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 +1835,12 @@ _getProp({}, 'a');
 _getProp({}, 1);
 
 _getProp({
-  unkonwnProperty() {}
+  unknownProperty() {}
 
 }, 'a');
 
 _getProp({
-  unkonwnProperty() {}
+  unknownProperty() {}
 
 }, 1);
 
@@ -2125,7 +2122,6 @@ function eachProxyArrayDidChange(array, idx, removedCnt, addedCnt) {
   confusing.
 
   ```javascript
-  isNone();              // true
   isNone(null);          // true
   isNone(undefined);     // true
   isNone('');            // false
@@ -2159,7 +2155,6 @@ function isNone(obj) {
   to check emptiness.
 
   ```javascript
-  isEmpty();                 // true
   isEmpty(null);             // true
   isEmpty(undefined);        // true
   isEmpty('');               // true
@@ -2183,31 +2178,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 +2200,10 @@ function isEmpty(obj) {
     }
   }
 
+  if (typeof obj.length === 'number' && typeof obj !== 'function') {
+    return !obj.length;
+  }
+
   return false;
 }
 
@@ -2228,7 +2217,6 @@ function isEmpty(obj) {
   ```javascript
   import { isBlank } from '@ember/utils';
 
-  isBlank();                // true
   isBlank(null);            // true
   isBlank(undefined);       // true
   isBlank('');              // true
@@ -2262,7 +2250,6 @@ function isBlank(obj) {
   A value is present if it not `isBlank`.
 
   ```javascript
-  isPresent();                // false
   isPresent(null);            // false
   isPresent(undefined);       // false
   isPresent('');              // false
@@ -2769,7 +2756,7 @@ function mergeMixins(mixins, meta$$1, descs, values, base, keys, keysWithSuper)
       } else if (mixins !== undefined) {
         mergeMixins(mixins, meta$$1, descs, values, base, keys, keysWithSuper);
 
-        if (currentMixin._without !== undefined) {
+        if (currentMixin instanceof Mixin && currentMixin._without !== undefined) {
           currentMixin._without.forEach(keyName => {
             // deleting the key means we won't process the value
             let index = keys.indexOf(keyName);

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);
   }
   /**
@@ -943,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;
   }
   /**
@@ -1007,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.
 
@@ -1135,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);
@@ -1298,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, '.');
@@ -1331,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 {
@@ -1655,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,

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

@@ -1,6 +1,7 @@
 import { privatize as P } from '@ember/-internals/container';
 import { computed, get, set } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
+import { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { assert, deprecate, info } from '@ember/debug';
 import EmberError from '@ember/error';
@@ -16,6 +17,7 @@ import RouterState from './router_state';
 */
 
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
+import EngineInstance from '@ember/engine/instance';
 
 function defaultDidTransition(infos) {
   updatePaths(this);
@@ -77,7 +79,7 @@ const {
 
 class EmberRouter extends EmberObject.extend(Evented) {
   constructor(owner) {
-    super(...arguments);
+    super(owner);
     this._didSetupRouter = false;
     this._initialTransitionStarted = false;
     this.currentURL = null;
@@ -92,6 +94,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     this._handledErrors = new Set();
     this._engineInstances = Object.create(null);
     this._engineInfoByRoute = Object.create(null);
+    this._slowTransitionTimer = null;
     this.currentState = null;
     this.targetState = null;
 
@@ -99,7 +102,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     this.namespace = owner.lookup('application:main');
     let bucketCache = owner.lookup(P`-bucket-cache:main`);
-    assert('BUG: BucketCache should always be present', bucketCache !== undefined);
+    assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
     this._bucketCache = bucketCache;
     let routerService = owner.lookup('service:router');
     assert('BUG: RouterService should always be present', routerService !== undefined);
@@ -699,11 +702,13 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let instances = this._engineInstances;
 
     for (let name in instances) {
-      let instance = instances[name];
-      assert('has instance', instance);
+      let instanceMap = instances[name];
+      assert('has instanceMap', instanceMap);
 
-      for (let id in instance) {
-        run(instance[id], 'destroy');
+      for (let id in instanceMap) {
+        let instance = instanceMap[id];
+        assert('has instance', instance);
+        run(instance, 'destroy');
       }
     }
   }
@@ -916,7 +921,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     }
   }
 
-  _doTransition(_targetRouteName, models, _queryParams, _keepDefaultQueryParamValues) {
+  _doTransition(_targetRouteName, models, _queryParams, _fromRouterService) {
     let targetRouteName = _targetRouteName || getActiveTargetName(this._routerMicrolib);
 
     assert(`The route ${targetRouteName} was not found`, Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName));
@@ -927,7 +932,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     Object.assign(queryParams, _queryParams);
 
-    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_keepDefaultQueryParamValues));
+    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_fromRouterService));
 
     let transition = this._routerMicrolib.transitionTo(targetRouteName, ...models, {
       queryParams
@@ -1165,7 +1170,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
   _scheduleLoadingEvent(transition, originRoute) {
     this._cancelSlowTransitionTimer();
 
-    this._slowTransitionTimer = scheduleOnce('routerTransitions', this, '_handleSlowTransition', transition, originRoute);
+    this._slowTransitionTimer = scheduleOnce('routerTransitions', this, this._handleSlowTransition, transition, originRoute);
   }
 
   _handleSlowTransition(transition, originRoute) {
@@ -1221,7 +1226,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     if (!engineInstance) {
       let owner = getOwner(this);
-      assert('Router is unexpectedly missing an owner', owner);
+      assert('Expected router to have EngineInstance as owner', owner instanceof EngineInstance);
       assert(`You attempted to mount the engine '${name}' in your router map, but the engine can not be found.`, owner.hasRegistration(`engine:${name}`));
       engineInstance = owner.buildChildEngineInstance(name, {
         routable: true,
@@ -1526,16 +1531,6 @@ function updatePaths(router) {
   set(router, 'currentPath', path);
   set(router, 'currentRouteName', currentRouteName);
   set(router, 'currentURL', currentURL);
-  let owner = getOwner(router);
-  assert('Router is unexpectedly missing an owner', owner);
-  let appController = owner.lookup('controller:application');
-
-  if (!appController) {
-    // appController might not exist when top-level loading/error
-    // substates have been entered since ApplicationRoute hasn't
-    // actually been entered at that point.
-    return;
-  }
 }
 
 function didBeginTransition(transition, router) {
@@ -1634,7 +1629,7 @@ function representEmptyRoute(liveRoutes, defaultParentState, {
     // Create an entry to represent our default template name,
     // just so other routes can target it and inherit its place
     // in the outlet hierarchy.
-    defaultParentState.outlets.main = {
+    defaultParentState.outlets['main'] = {
       render: {
         name: routeName,
         outlet: 'main'

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

@@ -1,6 +1,7 @@
 import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { assert, deprecate } from '@ember/debug';
+import EngineInstance from '@ember/engine/instance';
 import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
@@ -219,7 +220,7 @@ export function resemblesURL(str) {
 export function prefixRouteNameArg(route, args) {
   let routeName;
   let owner = getOwner(route);
-  assert('Route is unexpectedly missing an owner', owner);
+  assert('Expected route to have EngineInstance as owner', owner instanceof EngineInstance);
   let prefix = owner.mountPoint; // only alter the routeName if it's actually referencing a route.
 
   if (owner.routable && typeof args[0] === 'string') {

package/dist/packages/@ember/-internals/runtime/lib/compare.js

@@ -1,5 +1,6 @@
 import { typeOf } from './type-of';
 import Comparable from './mixins/comparable';
+import { assert } from '@ember/debug';
 const TYPE_ORDER = {
   undefined: 0,
   null: 1,
@@ -31,8 +32,9 @@ const TYPE_ORDER = {
 //                                              SSt  `------'`
 
 function spaceship(a, b) {
-  let diff = a - b;
-  return (diff > 0) - (diff < 0);
+  let diff = a - b; // SAFETY: Number casts true into 1 and false into 0. Therefore, this must end up as one of the Compare values.
+
+  return Number(diff > 0) - Number(diff < 0);
 }
 /**
  @module @ember/utils
@@ -94,11 +96,12 @@ export default function compare(v, w) {
   let type1 = typeOf(v);
   let type2 = typeOf(w);
 
-  if (type1 === 'instance' && Comparable.detect(v) && v.constructor.compare) {
+  if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
     return v.constructor.compare(v, w);
   }
 
-  if (type2 === 'instance' && Comparable.detect(w) && w.constructor.compare) {
+  if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
+    // SAFETY: Multiplying by a negative just changes the sign
     return w.constructor.compare(w, v) * -1;
   }
 
@@ -111,14 +114,20 @@ export default function compare(v, w) {
 
   switch (type1) {
     case 'boolean':
+      assert('both are boolean', typeof v === 'boolean' && typeof w === 'boolean');
+      return spaceship(Number(v), Number(w));
+
     case 'number':
+      assert('both are numbers', typeof v === 'number' && typeof w === 'number');
       return spaceship(v, w);
 
     case 'string':
+      assert('both are strings', typeof v === 'string' && typeof w === 'string');
       return spaceship(v.localeCompare(w), 0);
 
     case 'array':
       {
+        assert('both are arrays', Array.isArray(v) && Array.isArray(w));
         let vLen = v.length;
         let wLen = w.length;
         let len = Math.min(vLen, wLen);
@@ -137,16 +146,21 @@ export default function compare(v, w) {
       }
 
     case 'instance':
-      if (Comparable.detect(v)) {
+      if (isComparable(v) && v.compare) {
         return v.compare(v, w);
       }
 
       return 0;
 
     case 'date':
+      assert('both are dates', v instanceof Date && w instanceof Date);
       return spaceship(v.getTime(), w.getTime());
 
     default:
       return 0;
   }
+}
+
+function isComparable(value) {
+  return Comparable.detect(value);
 }

package/dist/packages/@ember/-internals/runtime/lib/ext/rsvp.js

@@ -25,13 +25,17 @@ export function onerrorDefault(reason) {
 
 function errorFor(reason) {
   if (!reason) return;
+  let withErrorThrown = reason;
 
-  if (reason.errorThrown) {
-    return unwrapErrorThrown(reason);
+  if (withErrorThrown.errorThrown) {
+    return unwrapErrorThrown(withErrorThrown);
   }
 
-  if (reason.name === 'UnrecognizedURLError') {
-    assert(`The URL '${reason.message}' did not match any routes in your application`, false);
+  let withName = reason;
+
+  if (withName.name === 'UnrecognizedURLError') {
+    assert(`The URL '${withName.message}' did not match any routes in your application`, false); // @ts-expect-error We'll hit this if the assert is stripped
+
     return;
   }