chore(*): Added some more typing information

Author: christopherthielen

src/common/common.ts

@@ -99,7 +99,7 @@ export function indexOf(array, value) {
   return -1;
 }
 
-export const removeFrom = (array) => (obj) => {
+export const removeFrom = (array: any[]) => (obj) => {
   var idx = array.indexOf(obj);
   if (idx >= 0) array.splice(idx, 1);
   return array;
@@ -379,7 +379,7 @@ export function isEq(fn1: F, fn2: F): () => boolean {
   };
 }
 
-export function val(v): F {
+export function val<T>(v: T): () => T {
   return function() { return v; };
 }
 

src/interface.ts

@@ -0,0 +1,57 @@
+import {UrlMatcher} from "url/urlMatcher";
+import {ParamSet} from "params/paramSet";
+
+/** View declaration inside state declaration */
+export interface IViewDeclaration {
+  controllerProvider?: Function;
+  controller?: any;
+  template?: any;
+  templateUrl?: any;
+  templateProvider?: Function;
+}
+
+/** hash of strings->views */
+interface IViewDeclarations     { [key:string]: IViewDeclaration; }
+/** hash of strings->resolve fns */
+interface IResolveDeclarations  { [key:string]: Function; }
+/** hash of strings->param declarations */
+// If the value is of type 'any', then it is syntax sugar for an IParamDeclaration { value: value }
+interface IParamsDeclaration    { [key:string]: (IParamDeclaration|any) }
+/** declaration of single state param */
+interface IParamDeclaration {
+  value: any;
+  squash: (boolean|string);
+}
+
+/** state declaration */
+export interface IStateDeclaration extends IViewDeclaration {
+  name: string;
+  abstract: boolean;
+  parent: (string|IStateDeclaration);
+  resolve: IResolveDeclarations; // name->Function
+  resolvePolicy: (string|Object);
+  url: string;
+  params: IParamsDeclaration;
+  views: IViewDeclarations;
+  data: any;
+  // TODO: finish defining state definition API.  Maybe start with what's on Definitely Typed.
+}
+
+/** internal state API */
+export interface IState {
+  name: string;
+  abstract: boolean;
+  parent: IState;
+  resolve: IResolveDeclarations; // name->Function
+  resolvePolicy: (string|Object);
+  url: UrlMatcher;
+  params: ParamSet;
+  ownParams: ParamSet;
+  views: IViewDeclarations;
+  self: IStateDeclaration;
+  root: () => IState;
+  navigable: IState;
+  path: IState[];
+  data: any;
+  includes: (name: string) => boolean;
+}

src/resolve/path.ts

@@ -4,7 +4,7 @@ import {extend, isArray, identity, noop} from "../common/common";
 import {defaults, map, omit, pluck, find, pipe, prop, eq}  from "../common/common";
 import {trace}  from "../common/trace";
 import {IPromise} from "angular";
-import {IPublicState} from "../state/state";
+import {IState} from "../interface";
 import {runtime} from "../common/angular1"
 import PathElement from "./pathElement";
 import Resolvable from "./resolvable";
@@ -25,7 +25,7 @@ import Resolvable from "./resolvable";
  */
 
 class Path {
-  constructor(statesOrPathElements: (IPublicState[] | PathElement[])) {
+  constructor(statesOrPathElements: (IState[] | PathElement[])) {
     if (!isArray(statesOrPathElements))
       throw new Error("states must be an array of state(s) or PathElement(s): ${statesOrPathElements}");
 
@@ -101,11 +101,11 @@ class Path {
     return this;
   }
 
-  states(): IPublicState[] {
+  states(): IState[] {
     return pluck(this.elements, "state");
   }
 
-  elementForState(state: IPublicState): PathElement {
+  elementForState(state: IState): PathElement {
     return find(this.elements, pipe(prop('state'), eq(state)));
   }
 

src/resolve/pathElement.ts

@@ -3,7 +3,7 @@
 import {isObject, isString, extend, forEach, noop, pick, map, filter, parse} from "../common/common";
 import {trace}  from "../common/trace";
 import {IPromise} from "angular";
-import {IPublicState} from "../state/state";
+import {IState} from "../interface";
 import Path from "./path";
 import Resolvable from "./resolvable";
 import {runtime} from "../common/angular1"
@@ -23,15 +23,15 @@ var defaultResolvePolicy = "jit"; // TODO: make this configurable
  * on the fly.
  */
 export default class PathElement {
-  constructor(state: IPublicState) {
+  constructor(state: IState) {
     this.state = state;
     // Convert state's resolvable assoc-array into an assoc-array of empty Resolvable(s)
     this._resolvables = map(state.resolve || {}, function(resolveFn, resolveName) {
       return new Resolvable(resolveName, resolveFn, state);
     });
   }
 
-  state: IPublicState;
+  state: IState;
   private _resolvables: Object;
 
   getResolvables(): Object {

src/resolve/resolvable.ts

@@ -3,7 +3,7 @@
 import {pick, map}  from "../common/common";
 import {trace}  from "../common/trace";
 import {IPromise} from "angular";
-import {IPublicState} from "../state/state";
+import {IState} from "../interface";
 import {runtime} from "../common/angular1"
 
 /**
@@ -19,7 +19,7 @@ import {runtime} from "../common/angular1"
  * parameter to those fns.
  */
 class Resolvable {
-  constructor(name: string, resolveFn: Function, state: IPublicState) {
+  constructor(name: string, resolveFn: Function, state: IState) {
     this.name = name;
     this.resolveFn = resolveFn;
     this.state = state;
@@ -28,7 +28,7 @@ class Resolvable {
 
   name: String;
   resolveFn: Function;
-  state: IPublicState;
+  state: IState;
   deps: string[];
 
   promise: IPromise<any> = undefined;

src/state/state.ts

@@ -7,33 +7,14 @@ import {defaultTransOpts} from "../transition/transitionService";
 import {Param} from "../params/param";
 import {ParamSet} from "../params/paramSet";
 import {IServiceProviderFactory} from "angular";
-
-export interface IPublicState {
-  name: string;
-  resolve: any; // key->Function
-  url: string;
-  resolvePolicy: (string|Object);
-  // TODO: finish defining state API.  Maybe start with what's on Definitely Typed.
-}
-
-export interface IState {
-  name: string;
-  resolve: any; // key->Function
-  url: string;
-  resolvePolicy: (string|Object);
-  self: IPublicState;
-  params: ParamSet;
-  root(): IState;
-  path: IState[];
-  // TODO: finish defining state API.  Maybe start with what's on Definitely Typed.
-}
-
+import {UrlMatcher} from "../url/urlMatcher";
+import {IState, IStateDeclaration} from "../interface";
 
 export function StateQueueManager(states, builder, $urlRouterProvider, $state) {
   var queue = [];
 
   var queueManager = extend(this, {
-    register: function(config: IPublicState, pre?: boolean) {
+    register: function(config: IStateDeclaration, pre?: boolean) {
       // Wrap a new object around the state so we can store our private details easily.
       var state = inherit(new State(), extend({}, config, {
         self: config,
@@ -307,7 +288,7 @@ export function StateMatcher(states) {
  *
  * @returns {Object}  Returns a new `State` object.
  */
-function State(config?: IPublicState) {
+function State(config?: IStateDeclaration) {
   extend(this, config);
 }
 
@@ -406,7 +387,7 @@ export class StateReference {
     return this._definition;
   }
 
-  state(): IPublicState {
+  state(): IStateDeclaration {
     return this._definition && this._definition.self;
   }
 

src/transition/transition.ts

@@ -11,7 +11,8 @@ import Resolvable from "../resolve/resolvable";
 import Path from "../resolve/path";
 import PathElement from "../resolve/pathElement";
 import {RejectFactory} from "./rejectFactory"
-import {StateParams, StateReference, IState, IPublicState} from "../state/state";
+import {StateParams, StateReference} from "../state/state"
+import {IState, IStateDeclaration} from "../interface";
 import {ViewContext} from "../view/viewContext";
 import {StateViewConfig} from "../view/view";
 import {defaults, eq, extend, filter, flatten, forEach, identity, invoke, is, isEq, isFunction, isObject, isPromise, isDefined,
@@ -262,6 +263,10 @@ export class Transition {
     return new ViewContext(pathElement, this._treeChanges.to, this._options, runtime.$injector);
   }
 
+  /**
+   * Returns a list of StateViewConfig objects;
+   * Returns one StateViewConfig for each view in each state in a named path of the transition's tree changes
+   */
   views(pathname: string = "entering") {
     var path = this._treeChanges[pathname];
     var states = states || path.states();
@@ -338,7 +343,7 @@ export class Transition {
     var options = this._options;
     var tLocals = {$transition$: this};
 
-    var rootPE = new PathElement(this._from.$state().root().self);
+    var rootPE = new PathElement(this._from.$state().root());
     var rootPath = new Path([rootPE]);
     var exitingElements = exiting.slice(0).reverse().elements;
     var enteringElements = entering.elements;

src/transition/transitionHook.ts

@@ -4,7 +4,7 @@ import {RejectFactory} from "./rejectFactory";
 import PathElement from "../resolve/pathElement";
 import Path from "../resolve/path";
 import {Transition} from "./transition";
-import {IPublicState} from "../state/state";
+import {IState} from "../interface";
 import Resolvable from "../resolve/resolvable";
 
 var REJECT = new RejectFactory();
@@ -23,7 +23,7 @@ export default class TransitionHook {
   // TODO these are redundant, check why we're doubling up on them.
   async: boolean;
   rejectIfSuperseded: boolean;
-  state: IPublicState;
+  state: IState;
   data: any;
 
   constructor(pathElement: PathElement, fn: Function, locals: any, pathContext: Path, options: any) {

src/transition/transitionService.ts

@@ -3,15 +3,15 @@
 import {IServiceProviderFactory} from "angular";
 import {Transition} from "./transition";
 import {Glob} from "../state/glob";
-import {IPublicState, IState} from "../state/state";
+import {IStateDeclaration, IState} from "../interface";
 import {extend, is, isFunction, isString, val, noop} from "../common/common";
 
 export interface ITransitionOptions {
   location    ?: boolean,
-  relative    ?: (boolean|IPublicState|IState),
+  relative    ?: (boolean|IStateDeclaration|IState),
   inherit     ?: boolean,
   notify      ?: boolean,
-  reload      ?: (boolean|string|IPublicState|IState),
+  reload      ?: (boolean|string|IStateDeclaration|IState),
   reloadState ?: (IState),
   trace       ?: boolean,
   custom      ?: any,

src/view/viewContext.ts

@@ -1,17 +1,17 @@
 import Path from "../resolve/path";
 import PathElement from "../resolve/pathElement";
-import {IPublicState} from "../state/state";
+import {IState} from "../interface";
 import {objectKeys, zipObject, pick} from "../common/common";
 
 export class ViewContext {
-  state: IPublicState;
+  //state: IState;
   _pathElement: PathElement;
   _path: Path;
   _options: any;
   _injector: ng.auto.IInjectorService;
 
   constructor(pathElement: PathElement, path: Path, options: any, $injector: ng.auto.IInjectorService) {
-    this.state = pathElement.state;
+    //this.state = pathElement.state;
     this._pathElement = pathElement;
     this._path = path;
     this._options = options;