refactor(*): consolidate path handling

Author: nateabele

src/common/common.ts

@@ -391,8 +391,9 @@ export function padString(length: number, str: string) {
   return str;
 }
 
-export function tail(array: any[]) {
-  return array.length && array[array.length - 1] || undefined;
+export function tail<T>(collection: T[]): T;
+export function tail(collection: any[]): any {
+  return collection.length && collection[collection.length - 1] || undefined;
 }
 
 

src/params/interface.ts

@@ -1,6 +1,4 @@
-import ParamValues from "./paramValues";
-
 export interface IRawParams {
     [key: string]: any
 }
-export type IParamsOrArray = (IRawParams|IRawParams[]|ParamValues);
+export type IParamsOrArray = (IRawParams|IRawParams[]);

src/params/module.ts

@@ -1,14 +1,8 @@
 import * as param from "./param";
 export {param};
 
-import * as paramSet from "./paramSet";
-export {paramSet};
-
 import * as paramTypes from "./paramTypes";
 export {paramTypes};
 
-import * as paramValues from "./paramValues";
-export {paramValues};
-
 import * as type from "./type";
 export {type};

src/params/param.ts

@@ -1,4 +1,5 @@
-import {isInjectable, extend, isDefined, isString, isArray, filter, map, pick, prop, propEq, curry} from "../common/common";
+import {isInjectable, extend, isDefined, isString, isArray, filter, map, pick, prop, propEq, curry, applyPairs} from "../common/common";
+import {IRawParams} from "../params/interface";
 import {runtime} from "../common/angular1";
 import matcherConfig from "../url/urlMatcherConfig";
 import paramTypes from "./paramTypes";
@@ -143,4 +144,20 @@ export default class Param {
   static fromSearch(id: string, type: Type, config: any): Param {
     return new Param(id, type, config, DefType.SEARCH);
   }
+
+  static values(params: Param[], values): IRawParams {
+    values = values || {};
+    return <IRawParams> params.map(param => [param.id, param.value(values[param.id])]).reduce(applyPairs, {});
+  }
+
+  static equals(params: Param[], values1, values2): boolean {
+    values1 = values1 || {};
+    values2 = values2 || {};
+    return params.map(param => param.type.equals(values1[param.id], values2[param.id])).indexOf(false) === -1;
+  }
+
+  static validates(params: Param[], values): boolean {
+    values = values || {};
+    return params.map(param => param.validates(values[param.id])).indexOf(false) === -1;
+  }
 }

src/params/paramSet.ts

@@ -1,49 +1,29 @@
-
-import Path from "./../path/path";
-
-import {IState} from "../state/interface";
+import {State} from "../state/state";
+import Node from "../path/node";
 
 import {ViewConfig} from "../view/view";
 
 import {IRawParams} from "../params/interface";
-import ParamValues from "../params/paramValues";
 
 import {IResolvables} from "../resolve/interface";
 import ResolveContext from "../resolve/resolveContext";
 import ResolveInjector from "../resolve/resolveInjector";
 
-/** Base data (contains a state) for a node in a Path */
-export interface INode {
-  state: IState;
-}
-/** A basic Path. Each node contains an IState */
-export interface IPath extends Path<INode> {}
 
-
-/** Contains INode base data plus raw params values for the node */
-export interface IParamsNode extends INode {
-  ownParamValues: IRawParams;
+/** Contains Node base data plus raw params values for the node */
+export interface IParamsNode extends Node {
+  values: IRawParams;
 }
-/** A Path of IParamsNode(s) */
-export interface IParamsPath extends Path<IParamsNode> {}
-
 
 /** Contains IParamsNode data, plus Resolvables for the node */
 export interface IResolveNode extends IParamsNode {
-  ownResolvables: IResolvables;
+  resolves: IResolvables;
 }
-/** A Path of IResolveNode(s) */
-export interface IResolvePath extends Path<IResolveNode> {}
 
 /** Contains IResolveNode data, plus a ResolveContext and ParamsValues (bound to a full path) for the node,  */
 export interface ITransNode extends IResolveNode {
   resolveContext: ResolveContext;
   resolveInjector: ResolveInjector;
   views: ViewConfig[];
-  paramValues: ParamValues;
+  // paramValues: ParamValues;
 }
-/**
- * A Path of ITransNode(s). Each node contains raw param values, Resolvables and also a ResolveContext
- * and ParamValues which are bound to the overall path, but isolated to the node.
- */
-export interface ITransPath extends Path<ITransNode> {}

src/params/paramValues.ts

@@ -1,5 +1,5 @@
-import * as path from "./path";
-export {path};
+import * as Node from "./node";
+export {Node};
 
 import * as pathFactory from "./pathFactory";
 export {pathFactory};

src/path/interface.ts

@@ -0,0 +1,69 @@
+/// <reference path='../../typings/angularjs/angular.d.ts' />
+import {extend, pick, prop, propEq, pairs, map, find} from "../common/common";
+import {State} from "../state/state";
+import Param from "../params/param";
+import Type from "../params/type";
+import {IRawParams} from "../params/interface";
+import Resolvable from "../resolve/resolvable";
+import ResolveContext from "../resolve/resolveContext";
+import ResolveInjector from "../resolve/resolveInjector";
+import {ViewConfig} from "../view/view";
+
+export default class Node {
+
+  public schema:   Param[];
+  public values:   { [key: string]: any };
+  public resolves: any;
+  public views:    ViewConfig[];
+  public resolveContext: ResolveContext;
+  public resolveInjector: ResolveInjector;
+
+  // Possibly extract this logic into an intermediary object that maps states to nodes
+  constructor(public state: State, params: IRawParams, resolves: any = {}) {
+    const schema: Param[] = state.parameters({ inherit: false });
+    // schema = keys.map(key => [key, state.parameter(key)]).reduce(applyPairs, {});
+
+    // Object.freeze(extend(this, { ... }))
+    extend(this, {
+      state,
+      schema,
+      values: pick(params, schema.map(prop('id'))),
+      resolves: map(
+        extend(state.resolve || {}, resolves),
+        (fn: Function, name: string) => new Resolvable(name, fn, state)
+      ),
+      views: pairs(state.views || {}).map(([rawViewName, viewDeclarationObj]): ViewConfig => {
+        return new ViewConfig({
+          rawViewName, viewDeclarationObj, context: state, params
+        });
+      })
+    });
+  }
+
+  parameter(name: string): Param {
+    return find(this.schema, prop('id'));
+  }
+
+  equals(node: Node, keys?: string[]): boolean {
+    return this.state === node.state && (keys || Object.keys(this.values)).map(key => {
+      return this.parameter(key).type.equals(this.values[key], node.values[key]);
+    }).reduce((previous, current) => previous && current, true);
+  }
+
+  static clone(node: Node, update: any = {}) {
+    return new Node(node.state, update.params || node.values, update.resolves || map(node.resolves, prop('resolveFn')));
+  }
+
+  /**
+   * Returns a new path which is a subpath of this path. The new path starts from root and contains any nodes
+   * that match the nodes in the second path. Nodes are compared using their state properties.
+   * @param first {Node[]}
+   * @param second {Node[]}
+   * @returns {Node[]}
+   */
+  static matching(first: Node[], second: Node[]): Node[] {
+    let matchedCount = first.reduce((prev, node, i) =>
+      prev === i && i < second.length && node.state === second[i].state ? i + 1 : prev, 0);
+    return first.slice(matchedCount);
+  }
+}