chore(routing): update routing package

packages/angular/src/nav/router/router.ts

@@ -0,0 +1,113 @@
+
+
+import {
+  Event,
+  NavigationCancel,
+  NavigationEnd,
+  NavigationError,
+  Router,
+  RouterState,
+  UrlTree
+} from '@angular/router';
+
+import { Observable } from 'rxjs/Observable';
+import {Subject} from 'rxjs/Subject';
+
+import { AsyncActivateRoutes } from './async-activated-routes';
+
+export class CustomRouter extends Router {
+
+  protected activateRoutes(state: Observable<{appliedUrl: string, state: RouterState, shouldActivate: boolean}>, storedState: RouterState,
+    storedUrl: UrlTree, id: number, url: UrlTree, rawUrl: UrlTree, skipLocationChange: boolean, replaceUrl: boolean, resolvePromise: any, rejectPromise: any) {
+
+      console.log('custom activateRoutes!!!!1');
+
+      // applied the new router state
+    // this operation has side effects
+    let navigationIsSuccessful: boolean;
+
+    const routes: AsyncActivateRoutes[] = [];
+    state
+      .forEach(({appliedUrl, state, shouldActivate}: any) => {
+        if (!shouldActivate || id !== this.navigationId) {
+          navigationIsSuccessful = false;
+          return;
+        }
+
+        this.currentUrlTree = appliedUrl;
+        this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, rawUrl);
+
+        (this as{routerState: RouterState}).routerState = state;
+
+        if (!skipLocationChange) {
+          const path = this.urlSerializer.serialize(this.rawUrlTree);
+          if (this.location.isCurrentPathEqualTo(path) || replaceUrl) {
+            this.location.replaceState(path, '');
+          } else {
+            this.location.go(path, '');
+          }
+        }
+
+        routes.push(new AsyncActivateRoutes(this.routeReuseStrategy, state, storedState, (evt: Event) => this.triggerEvent(evt)))
+
+
+      })
+      .then(
+        () => {
+          const promises = routes.map(activatedRoute => activatedRoute.activate(this.rootContexts));
+          return Promise.all(promises)
+            .then(
+              () => {
+                navigationIsSuccessful = true;
+              }
+            );
+        }
+      )
+      .then(
+          () => {
+            if (navigationIsSuccessful) {
+              this.navigated = true;
+              this.lastSuccessfulId = id;
+              (this.events as Subject<Event>)
+                  .next(new NavigationEnd(
+                      id, this.serializeUrl(url), this.serializeUrl(this.currentUrlTree)));
+              resolvePromise(true);
+            } else {
+              this.resetUrlToCurrentUrlTree();
+              (this.events as Subject<Event>)
+                  .next(new NavigationCancel(id, this.serializeUrl(url), ''));
+              resolvePromise(false);
+            }
+          },
+          (e: any) => {
+            if (isNavigationCancelingError(e)) {
+              this.navigated = true;
+              this.resetStateAndUrl(storedState, storedUrl, rawUrl);
+              (this.events as Subject<Event>)
+                  .next(new NavigationCancel(id, this.serializeUrl(url), e.message));
+
+              resolvePromise(false);
+            } else {
+              this.resetStateAndUrl(storedState, storedUrl, rawUrl);
+              (this.events as any as Subject<Event>)
+                  .next(new NavigationError(id, this.serializeUrl(url), e));
+              try {
+                resolvePromise(this.errorHandler(e));
+              } catch (ee) {
+                rejectPromise(ee);
+              }
+            }
+          });
+  }
+
+  triggerEvent(e: Event): void { (this.events as any as Subject<Event>).next(e); }
+
+  serializeUrl(url: UrlTree): string { return this.urlSerializer.serialize(url); }
+
+}
+
+const NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
+
+export function isNavigationCancelingError(error: Error) {
+  return error && (error as any)[NAVIGATION_CANCELING_ERROR];
+}