refactor(StateMatcher): made ES6 class for StateMatcher

Author: christopherthielen

src/state/state.ts

@@ -112,7 +112,7 @@ State.prototype.root = function() {
 $StateProvider.$inject = ['$urlRouterProvider', '$urlMatcherFactoryProvider'];
 function $StateProvider(   $urlRouterProvider,   $urlMatcherFactoryProvider) {
 
-  var root, states = {};
+  var root, states: {[key: string]: IState} = {};
   var $state: any = function $state() {};
 
   var matcher    = new StateMatcher(states);
@@ -806,9 +806,10 @@ function $StateProvider(   $urlRouterProvider,   $urlMatcherFactoryProvider) {
      * @param {string|object=} context When stateOrName is a relative state reference, the state will be retrieved relative to context.
      * @returns {Object|Array} State configuration object or array of all objects.
      */
-    $state.get = function (stateOrName, context) {
+    $state.get = function (stateOrName, context): (IStateDeclaration|IStateDeclaration[]) {
       if (arguments.length === 0) return objectKeys(states).map(function(name) { return states[name].self; });
-      return (matcher.find(stateOrName, context || $state.$current) || {}).self || null;
+      var found = matcher.find(stateOrName, context || $state.$current);
+        return found && found.self || null;
     };
 
     return $state;

src/state/stateMatcher.ts

@@ -1,50 +1,57 @@
 import {extend, isString} from "../common/common"
 import StateReference from "./stateReference"
+import {IState, IStateDeclaration} from "./interface"
 
-export default function StateMatcher(states) {
-  extend(this, {
-    isRelative: function(stateName) {
-      stateName = stateName || "";
-      return stateName.indexOf(".") === 0 || stateName.indexOf("^") === 0;
-    },
+type PStateRef = (string|IStateDeclaration|IState);
 
-    find: function(stateOrName, base) {
-      if (!stateOrName && stateOrName !== "") return undefined;
-      var isStr = isString(stateOrName), name = isStr ? stateOrName : stateOrName.name;
 
-      if (this.isRelative(name)) name = this.resolvePath(name, base);
-      var state = states[name];
+export default class StateMatcher {
+  constructor (private _states: {[key: string]: IState}) { }
+  
+  isRelative(stateName: string) {
+    stateName = stateName || "";
+    return stateName.indexOf(".") === 0 || stateName.indexOf("^") === 0;
+  }
 
-      if (state && (isStr || (!isStr && (state === stateOrName || state.self === stateOrName)))) {
-        return state;
+
+  find(stateOrName: PStateRef, base?: PStateRef): IState {
+    if (!stateOrName && stateOrName !== "") return undefined;
+    let isStr = isString(stateOrName);
+    let name: string = isStr ? stateOrName : (<any>stateOrName).name;
+
+    if (this.isRelative(name)) name = this.resolvePath(name, base);
+    var state = this._states[name];
+
+    if (state && (isStr || (!isStr && (state === stateOrName || state.self === stateOrName)))) {
+      return state;
+    }
+    return undefined;
+  }
+
+  reference(identifier: PStateRef, base: PStateRef, params): StateReference {
+    return new StateReference(identifier, this.find(identifier, base), params, base);
+  }
+
+  resolvePath(name: string, base: PStateRef) {
+    if (!base) throw new Error(`No reference point given for path '${name}'`);
+    
+    let baseState: IState = this.find(base);
+
+    var splitName = name.split("."), i = 0, pathLength = splitName.length, current = baseState;
+
+    for (; i < pathLength; i++) {
+      if (splitName[i] === "" && i === 0) {
+        current = baseState;
+        continue;
       }
-      return undefined;
-    },
-
-    reference: function(identifier, base, params) {
-      return new StateReference(identifier, this.find(identifier, base), params, base);
-    },
-
-    resolvePath: function(name, base) {
-      if (!base) throw new Error(`No reference point given for path '${name}'`);
-      base = this.find(base);
-
-      var rel = name.split("."), i = 0, pathLength = rel.length, current = base;
-
-      for (; i < pathLength; i++) {
-        if (rel[i] === "" && i === 0) {
-          current = base;
-          continue;
-        }
-        if (rel[i] === "^") {
-          if (!current.parent) throw new Error(`Path '${name}' not valid for state '${base.name}'`);
-          current = current.parent;
-          continue;
-        }
-        break;
+      if (splitName[i] === "^") {
+        if (!current.parent) throw new Error(`Path '${name}' not valid for state '${baseState.name}'`);
+        current = current.parent;
+        continue;
       }
-      rel = rel.slice(i).join(".");
-      return current.name + (current.name && rel ? "." : "") + rel;
+      break;
     }
-  });
+    let relName = splitName.slice(i).join(".");
+    return current.name + (current.name && relName ? "." : "") + relName;
+  }
 }