refactor(Node): rename attrs to be more descriptive

Author: christopherthielen

src/path/node.ts

@@ -9,8 +9,8 @@ import {ViewConfig} from "../view/view";
 
 export class Node {
 
-  public schema:   Param[];
-  public values:   { [key: string]: any };
+  public paramSchema:   Param[];
+  public paramValues:   { [key: string]: any };
   public resolves: any;
   public views:    ViewConfig[];
   public resolveContext: ResolveContext;
@@ -19,10 +19,10 @@ export class Node {
   // Possibly extract this logic into an intermediary object that maps states to nodes
   constructor(public state: State, params: RawParams = {}, resolves: any = {}) {
     // Object.freeze(extend(this, { ... }))
-    this.schema = state.parameters({ inherit: false });
+    this.paramSchema = state.parameters({ inherit: false });
 
     const getParamVal = (paramDef: Param) => [ paramDef.id, paramDef.value(params[paramDef.id]) ];
-    this.values = this.schema.reduce((memo, pDef) => applyPairs(memo, getParamVal(pDef)), {});
+    this.paramValues = this.paramSchema.reduce((memo, pDef) => applyPairs(memo, getParamVal(pDef)), {});
 
     this.resolves = extend(map(state.resolve, (fn: Function, name: string) => new Resolvable(name, fn)), resolves);
 
@@ -32,16 +32,16 @@ export class Node {
   }
 
   parameter(name: string): Param {
-    return find(this.schema, propEq("id", name));
+    return find(this.paramSchema, propEq("id", name));
   }
 
-  equals(node: Node, keys = this.schema.map(prop('id'))): boolean {
-    const paramValsEq = key => this.parameter(key).type.equals(this.values[key], node.values[key]);
+  equals(node: Node, keys = this.paramSchema.map(prop('id'))): boolean {
+    const paramValsEq = key => this.parameter(key).type.equals(this.paramValues[key], node.paramValues[key]);
     return this.state === node.state && keys.map(paramValsEq).reduce(allTrueR, true);
   }
 
   static clone(node: Node, update: any = {}) {
-    return new Node(node.state, (update.values || node.values), (update.resolves || node.resolves));
+    return new Node(node.state, (update.paramValues || node.paramValues), (update.resolves || node.resolves));
   }
 
   /**

src/path/pathFactory.ts

@@ -21,7 +21,7 @@ export class PathFactory {
   /** Given a Node[], create an TargetState */
   static makeTargetState(path: Node[]): TargetState {
     let state = tail(path).state;
-    return new TargetState(state, state, path.map(prop("values")).reduce(mergeR, {}));
+    return new TargetState(state, state, path.map(prop("paramValues")).reduce(mergeR, {}));
   }
 
   /* Given params and a state, creates an Node */
@@ -50,8 +50,8 @@ export class PathFactory {
    */
   static inheritParams(fromPath: Node[], toPath: Node[], toKeys: string[] = []): Node[] {
     function nodeParamVals(path: Node[], state: State): RawParams {
-      let node = find(path, propEq('state', state));
-      return extend({}, node && node.values);
+      let node: Node = find(path, propEq('state', state));
+      return extend({}, node && node.paramValues);
     }
 
     /**
@@ -60,7 +60,7 @@ export class PathFactory {
      */
     let makeInheritedParamsNode = curry(function(_fromPath: Node[], _toKeys: string[], toNode: Node): Node {
       // All param values for the node (may include default key/vals, when key was not found in toParams)
-      let toParamVals = extend({}, toNode && toNode.values);
+      let toParamVals = extend({}, toNode && toNode.paramValues);
       // limited to only those keys found in toParams
       let incomingParamVals = pick(toParamVals, _toKeys);
       toParamVals = omit(toParamVals, _toKeys);
@@ -88,7 +88,7 @@ export class PathFactory {
     resolvePath.forEach((node: Node) => {
       node.resolveContext = resolveContext.isolateRootTo(node.state);
       node.resolveInjector = new ResolveInjector(node.resolveContext, node.state);
-      node.resolves.$stateParams = new Resolvable("$stateParams", () => node.values, node.values);
+      node.resolves.$stateParams = new Resolvable("$stateParams", () => node.paramValues, node.paramValues);
     });
 
     return resolvePath;
@@ -108,7 +108,7 @@ export class PathFactory {
 
     /** Given a retained node, return a new node which uses the to node's param values */
     function applyToParams(retainedNode: Node, idx: number): Node {
-      return Node.clone(retainedNode, { values: toPath[idx].values });
+      return Node.clone(retainedNode, { paramValues: toPath[idx].paramValues });
     }
 
     let from: Node[], retained: Node[], exiting: Node[], entering: Node[], to: Node[];

src/transition/transition.ts

@@ -179,7 +179,7 @@ export class Transition implements IHookRegistry {
    * @returns transition parameter values for the desired path.
    */
   params(pathname: string = "to"): { [key: string]: any } {
-    return this._treeChanges[pathname].map(prop("values")).reduce(mergeR, {});
+    return this._treeChanges[pathname].map(prop("paramValues")).reduce(mergeR, {});
   }
 
   /**
@@ -311,8 +311,8 @@ export class Transition implements IHookRegistry {
     let {to, from} = this._treeChanges;
     if (this._options.reload || tail(to).state !== tail(from).state) return false;
 
-    let nodeSchemas: Param[][] = to.map(node => node.schema.filter(not(prop('dynamic'))));
-    let [toValues, fromValues] = [to, from].map(path => path.map(prop('values')));
+    let nodeSchemas: Param[][] = to.map((node: Node) => node.paramSchema.filter(not(prop('dynamic'))));
+    let [toValues, fromValues] = [to, from].map(path => path.map(prop('paramValues')));
     let tuples = arrayTuples(nodeSchemas, toValues, fromValues);
 
     return tuples.map(([schema, toVals, fromVals]) => Param.equals(schema, toVals, fromVals)).reduce(allTrueR, true);
@@ -426,7 +426,7 @@ export class Transition implements IHookRegistry {
     // (X) means the to state is invalid.
     let id = this.$id,
         from = isObject(fromStateOrName) ? fromStateOrName.name : fromStateOrName,
-        fromParams = toJson(avoidEmptyHash(this._treeChanges.from.map(prop('values')).reduce(mergeR, {}))),
+        fromParams = toJson(avoidEmptyHash(this._treeChanges.from.map(prop('paramValues')).reduce(mergeR, {}))),
         toValid = this.valid() ? "" : "(X) ",
         to = isObject(toStateOrName) ? toStateOrName.name : toStateOrName,
         toParams = toJson(avoidEmptyHash(this.params()));