fix(Rejection): Silence "Error: Uncaught (in Exception)"

Closes #2676

src/common/common.ts

@@ -6,6 +6,7 @@
 
 import {isFunction, isString, isArray, isRegExp, isDate} from "./predicates";
 import { all, any, not, prop, curry } from "./hof";
+import {services} from "./coreservices";
 
 let w: any = typeof window === 'undefined' ? {} : window;
 let angular = w.angular || {};
@@ -538,9 +539,9 @@ function _arraysEq(a1, a2) {
  if (a1.length !== a2.length) return false;
  return arrayTuples(a1, a2).reduce((b, t) => b && _equals(t[0], t[1]), true);
 }
-//
-//const _addToGroup = (result, keyFn) => (item) =>
-// (result[keyFn(item)] = result[keyFn(item)] || []).push(item) && result;
-//const groupBy = (array, keyFn) => array.reduce((memo, item) => _addToGroup(memo, keyFn), {});
-//
-//
+
+// issue #2676
+export const silenceUncaughtInPromise = (promise: Promise<any>) =>
+ promise.catch(e => 0) && promise;
+export const silentRejection = (error: any) =>
+ silenceUncaughtInPromise(services.$q.reject(error));

src/state/stateService.ts

@@ -1,5 +1,5 @@
 /** @module state */ /** */
-import {extend, defaults } from "../common/common";
+import {extend, defaults, silentRejection, silenceUncaughtInPromise} from "../common/common";
 import {isDefined, isObject, isString} from "../common/predicates";
 import {Queue} from "../common/queue";
 import {services} from "../common/coreservices";
@@ -274,7 +274,7 @@ export class StateService {
  return this._handleInvalidTargetState(currentPath, ref);
 
  if (!ref.valid())
- return services.$q.reject(ref.error());
+ return <TransitionPromise> silentRejection(ref.error());
 
  /**
  * Special handling for Ignored, Aborted, and Redirected transitions
@@ -307,6 +307,8 @@ export class StateService {
 
  let transition = this.router.transitionService.create(currentPath, ref);
  let transitionToPromise = transition.run().catch(rejectedTransitionHandler(transition));
+ silenceUncaughtInPromise(transitionToPromise); // issue #2676
+
  // Return a promise for the transition, which also has the transition object on it.
  return extend(transitionToPromise, { transition });
  };

src/transition/rejectFactory.ts

@@ -1,7 +1,6 @@
 /** @module transition */ /** for typedoc */
 "use strict";
-import {extend} from "../common/common";
-import {services} from "../common/coreservices";
+import {extend, silentRejection} from "../common/common";
 import {stringify} from "../common/strings";
 
 export enum RejectType {
@@ -27,7 +26,7 @@ export class Rejection {
  }
 
  toPromise() {
- return extend(services.$q.reject(this), { _transitionRejection: this });
+ return extend(silentRejection(this), { _transitionRejection: this });
  }
 
  /** Returns true if the obj is a rejected promise created from the `asPromise` factory */

src/transition/transition.ts

@@ -487,9 +487,13 @@ export class Transition implements IHookRegistry {
 
  trace.traceTransitionStart(this);
 
+ // Chain the next hook off the previous
+ const appendHookToChain = (prev, nextHook) =>
+ prev.then(() => nextHook.invokeHook());
+
  // Run the hooks, then resolve or reject the overall deferred in the .then() handler
  hookBuilder.asyncHooks()
- .reduce((_chain, step) => _chain.then(step.invokeHook.bind(step)), syncResult)
+ .reduce(appendHookToChain, syncResult)
  .then(transitionSuccess, transitionError);
 
  return this.promise;

src/transition/transitionHook.ts

@@ -34,20 +34,15 @@ export class TransitionHook {
 
  private isSuperseded = () => this.options.current() !== this.options.transition;
 
- invokeHook(rethrow = false): Promise<any> {
+ invokeHook(): Promise<any> {
  let { options, hookFn, resolveContext } = this;
  trace.traceHookInvocation(this, options);
  if (options.rejectIfSuperseded && this.isSuperseded()) {
  return Rejection.superseded(options.current()).toPromise();
  }
 
- try {
- var hookResult = hookFn.call(options.bind, this.transition, resolveContext.injector(), this.stateContext);
- return this.handleHookResult(hookResult);
- } catch (error) {
- if (rethrow) throw error;
- return services.$q.reject(error);
- }
+ let hookResult = hookFn.call(options.bind, this.transition, resolveContext.injector(), this.stateContext);
+ return this.handleHookResult(hookResult);
  }
 
  /**
@@ -96,7 +91,7 @@ export class TransitionHook {
  let results = [];
  for (let i = 0; i < hooks.length; i++) {
  try {
- results.push(hooks[i].invokeHook(true));
+ results.push(hooks[i].invokeHook());
  } catch (exception) {
  if (!swallowExceptions) {
  return Rejection.aborted(exception).toPromise();

test/ng1/transitionSpec.ts

@@ -14,16 +14,18 @@ import {Transition} from "../../src/transition/transition";
 
 describe('transition', function () {
 
- var transitionProvider, matcher, pathFactory, statesMap, queue;
+ var $exceptionHandler, transitionProvider, matcher, pathFactory, statesMap, queue;
 
  var targetState = function(identifier, params = {}, options?) {
  options = options || {};
  var stateDefinition = matcher.find(identifier, options.relative);
  return new TargetState(identifier, stateDefinition, params, options);
  };
 
- beforeEach(module('ui.router', function ($transitionsProvider, $urlMatcherFactoryProvider) {
+ beforeEach(module('ui.router', function ($transitionsProvider, $urlMatcherFactoryProvider, $exceptionHandlerProvider) {
+ decorateExceptionHandler($exceptionHandlerProvider);
  transitionProvider = $transitionsProvider;
+
  var stateTree = {
  first: {},
  second: {},
@@ -71,7 +73,8 @@ describe('transition', function () {
 
  var makeTransition;
 
- beforeEach(inject(function ($transitions, $state) {
+ beforeEach(inject(function ($transitions, $state, _$exceptionHandler_) {
+ $exceptionHandler = _$exceptionHandler_;
  matcher = new StateMatcher(statesMap);
  queue.flush($state);
  makeTransition = function makeTransition(from, to, options) {
@@ -113,6 +116,7 @@ describe('transition', function () {
 
  it('$transition$.promise should reject on error', inject(function($transitions, $q) {
  var result = new PromiseResult();
+ $exceptionHandler.disabled = true;
 
  transitionProvider.onStart({ from: "*", to: "third" }, function($transition$) {
  result.setPromise($transition$.promise);
@@ -126,6 +130,7 @@ describe('transition', function () {
 
  it('$transition$.promise should reject on error in synchronous hooks', inject(function($transitions, $q) {
  var result = new PromiseResult();
+ $exceptionHandler.disabled = true;
 
  transitionProvider.onBefore({ from: "*", to: "third" }, function($transition$) {
  result.setPromise($transition$.promise);
@@ -298,6 +303,7 @@ describe('transition', function () {
  }));
 
  it('should be called even if other .onSuccess() callbacks fail (throw errors, etc)', inject(function($transitions, $q) {
+ $exceptionHandler.disabled = true;
  transitionProvider.onSuccess({ from: "*", to: "*" }, function() { throw new Error("oops!"); });
  transitionProvider.onSuccess({ from: "*", to: "*" }, function(trans) { states.push(trans.to().name); });
 
@@ -318,6 +324,7 @@ describe('transition', function () {
  }));
 
  it('should be called if any part of the transition fails.', inject(function($transitions, $q) {
+ $exceptionHandler.disabled = true;
  transitionProvider.onEnter({ from: "A", entering: "C" }, function() { throw new Error("oops!"); });
  transitionProvider.onError({ }, function(trans) { states.push(trans.to().name); });
 
@@ -327,6 +334,7 @@ describe('transition', function () {
  }));
 
  it('should be called for only handlers matching the transition.', inject(function($transitions, $q) {
+ $exceptionHandler.disabled = true;
  transitionProvider.onEnter({ from: "A", entering: "C" }, function() { throw new Error("oops!"); });
  transitionProvider.onError({ from: "*", to: "*" }, function() { hooks.push("splatsplat"); });
  transitionProvider.onError({ from: "A", to: "C" }, function() { hooks.push("AC"); });

test/testUtilsNg1.js

@@ -116,6 +116,25 @@ function html5Compat(html5mode) {
  return (angular.isObject(html5mode) && html5mode.hasOwnProperty("enabled") ? html5mode.enabled : html5mode);
 }
 
+/**
+ * The ng1 $exceptionHandler from angular-mocks will re-throw any exceptions thrown in a Promise.
+ * This chunk of code decorates the handler, allowing a test to disable that behavior.
+ * Inject $exceptionHandler and set `$exceptionHandler.disabled = true`
+ */
+function decorateExceptionHandler($exceptionHandlerProvider) {
+ var $get = $exceptionHandlerProvider.$get;
+
+ $exceptionHandlerProvider.$get = function() {
+ var realHandler = $get.apply($exceptionHandlerProvider, arguments);
+ function passThrough(e) {
+ if (!passThrough['disabled']) {
+ realHandler.apply(null, arguments);
+ }
+ }
+ return passThrough;
+ };
+}
+
 
 // Utils for test from core angular
 var noop = angular.noop,