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 that the app has loaded
+          resolve(app);
-        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 => {
-      path: this.location.hash.slice(1),
+      resolve({
-      priority: 0
+        path: this.location.hash.slice(1),
-    }
+        priority: 0
+      })
+    });
   }
 
   isDifferentPath(path) {

ionic/routing/router.ts

@@ -32,59 +32,81 @@ 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) {
-    let self = this;
+    return new Promise(resolve => {
-    let activeViewCtrl = self.activeViewController();
+      let self = this;
-    let matchedRoute = self.match(path) || fallbackRoute;
+      let activeViewCtrl = self.activeViewController();
+      let matchedRoute = self.match(path) || fallbackRoute;
 
-    function zoneLoad() {
+      function zoneLoad() {
-      self._app.zone().run(() => {
+        self._app.zone().run(() => {
-        activeViewCtrl.push(matchedRoute.cls);
+          activeViewCtrl.push(matchedRoute.cls);
-        self.lastPath(matchedRoute.path);
+          self.lastPath(matchedRoute.path);
-      });
+          resolve();
-    }
+        }, err => {
-
+          console.error(err);
-    if (activeViewCtrl && matchedRoute) {
-
-      if (matchedRoute.cls) {
-        zoneLoad();
-
-      } else if (matchedRoute.module) {
-        System.import(matchedRoute.module).then(m => {
-          if (m) {
-            matchedRoute.cls = m[matchedRoute.name];
-            zoneLoad();
-          }
         });
       }
-    }
+
+      if (activeViewCtrl && matchedRoute) {
+
+        if (matchedRoute.cls) {
+          zoneLoad();
+
+        } else if (matchedRoute.module) {
+          System.import(matchedRoute.module).then(m => {
+            if (m) {
+              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
-    let rtnPath = null;
+    return new Promise(resolve => {
-    let highestPriority = -1;
-    let currentState = null;
 
-    for (let name in stateManagers) {
+      let promises = [];
-      currentState = stateManagers[name].getCurrentPath();
+      for (let name in stateManagers) {
-      if (currentState.path && currentState.priority > highestPriority) {
+        promises.push(stateManagers[name].getCurrentPath());
-        rtnPath = currentState.path;
       }
-    }
 
-    return rtnPath;
+      // when all the promises have resolved then see which one wins
+      Promise.all(promises).then(results => {
+        let rtnPath = null;
+        let highestPriority = -1;
+        let state = null;
+
+        for (let i = 0; i < results.length; i++) {
+          state = results[i];
+          if (state.path && state.priority > highestPriority) {
+            rtnPath = state.path;
+          }
+        }
+
+        resolve(rtnPath);
+      });
+    });
   }
 
   stateChange(type, activeView) {