promise based getCurrentPath()

ionic/components/app/app.ts

@@ -205,10 +205,10 @@ export function ionicBootstrap(cls, config, router) {
       bootstrap(cls, injectableBindings).then(appRef => {
         app.load(appRef);
 
-        router.load(app, config, window);
+        router.load(window, app, config).then(() => {
-
           // resolve that the app has loaded
           resolve(app);
+        });
 
       }).catch(err => {
         console.error('ionicBootstrap', err);

ionic/routing/hash-url-state.ts

@@ -4,12 +4,10 @@ import * as util from '../util/util';
 
 class HashUrlStateManager {
 
-  constructor(router, ionicApp, ionicConfig, window) {
+  constructor(window, router) {
-    this.router = router;
-    this.ionicApp = ionicApp;
-    this.ionicConfig = ionicConfig;
     this.location = window.location;
     this.history = window.history;
+    this.router = router;
 
     window.addEventListener('popstate', ev => {
       this.onPopState(ev);
@@ -80,7 +78,7 @@ class HashUrlStateManager {
       } else if (newStateBackPath === lastLoadedStatePath) {
         // if the last loaded state path is the new state's
         // back path, then the user is moving forward
-        this.loadByPath(newStatePath);
+        this.router.loadByPath(newStatePath);
       }
 
     }
@@ -88,10 +86,12 @@ class HashUrlStateManager {
 
   getCurrentPath() {
     // Grab the path without the leading hash
-    return {
+    return new Promise(resolve => {
+      resolve({
         path: this.location.hash.slice(1),
         priority: 0
-    }
+      })
+    });
   }
 
   isDifferentPath(path) {

ionic/routing/router.ts

@@ -32,17 +32,22 @@ export class IonicRouter {
     }
   }
 
-  load(ionicApp, ionicConfig, window) {
+  load(window, ionicApp, ionicConfig) {
     // create each of the state manager classes
     for (let name in stateManagerClasses) {
-      stateManagers[name] = new stateManagerClasses[name](this, ionicApp, ionicConfig, window);
+      stateManagers[name] = new stateManagerClasses[name](window, this, ionicApp, ionicConfig);
     }
     stateManagerClasses = {};
 
-    this.loadByPath(this.getCurrentPath(), this.otherwise());
+    return new Promise(resolve => {
+      this.getCurrentPath().then(path => {
+        this.loadByPath(path, this.otherwise()).then(resolve);
+      });
+    });
   }
 
   loadByPath(path, fallbackRoute) {
+    return new Promise(resolve => {
       let self = this;
       let activeViewCtrl = self.activeViewController();
       let matchedRoute = self.match(path) || fallbackRoute;
@@ -51,6 +56,9 @@ export class IonicRouter {
         self._app.zone().run(() => {
           activeViewCtrl.push(matchedRoute.cls);
           self.lastPath(matchedRoute.path);
+          resolve();
+        }, err => {
+          console.error(err);
         });
       }
 
@@ -65,26 +73,40 @@ export class IonicRouter {
               matchedRoute.cls = m[matchedRoute.name];
               zoneLoad();
             }
+          }, err => {
+            console.error(err);
           });
         }
       }
+    });
   }
 
   getCurrentPath() {
     // check each of the state managers and the one with the
     // highest priority wins of knowing what path we are currently at
+    return new Promise(resolve => {
+
+      let promises = [];
+      for (let name in stateManagers) {
+        promises.push(stateManagers[name].getCurrentPath());
+      }
+
+      // when all the promises have resolved then see which one wins
+      Promise.all(promises).then(results => {
         let rtnPath = null;
         let highestPriority = -1;
-    let currentState = null;
+        let state = null;
 
-    for (let name in stateManagers) {
+        for (let i = 0; i < results.length; i++) {
-      currentState = stateManagers[name].getCurrentPath();
+          state = results[i];
-      if (currentState.path && currentState.priority > highestPriority) {
+          if (state.path && state.priority > highestPriority) {
-        rtnPath = currentState.path;
+            rtnPath = state.path;
           }
         }
 
-    return rtnPath;
+        resolve(rtnPath);
+      });
+    });
   }
 
   stateChange(type, activeView) {