angular-docs-cn/modules/@angular/router/src/recognize.ts

import {RouteSegment, UrlSegment, Tree, TreeNode, rootNode, UrlTree, RouteTree} from './segments';
import {RoutesMetadata, RouteMetadata} from './metadata/metadata';
import {Type, isBlank, isPresent, stringify} from './facade/lang';
import {ListWrapper, StringMapWrapper} from './facade/collection';
import {PromiseWrapper} from './facade/promise';
import {BaseException} from '@angular/core';
import {ComponentResolver} from '@angular/core';
import {DEFAULT_OUTLET_NAME} from './constants';
import {reflector} from '@angular/core';

export function recognize(componentResolver: ComponentResolver, rootComponent: Type,
                          url: UrlTree): Promise<RouteTree> {
  let matched = new _MatchResult(rootComponent, [url.root], {}, rootNode(url).children, []);
  return _constructSegment(componentResolver, matched).then(roots => new RouteTree(roots[0]));
}

function _recognize(componentResolver: ComponentResolver, parentComponent: Type,
                    url: TreeNode<UrlSegment>): Promise<TreeNode<RouteSegment>[]> {
  let metadata = _readMetadata(parentComponent);  // should read from the factory instead
  if (isBlank(metadata)) {
    throw new BaseException(
        `Component '${stringify(parentComponent)}' does not have route configuration`);
  }

  let match;
  try {
    match = _match(metadata, url);
  } catch (e) {
    return PromiseWrapper.reject(e, null);
  }

  let main = _constructSegment(componentResolver, match);
  let aux =
      _recognizeMany(componentResolver, parentComponent, match.aux).then(_checkOutletNameUniqueness);
  return PromiseWrapper.all([main, aux]).then(ListWrapper.flatten);
}

function _recognizeMany(componentResolver: ComponentResolver, parentComponent: Type,
                        urls: TreeNode<UrlSegment>[]): Promise<TreeNode<RouteSegment>[]> {
  let recognized = urls.map(u => _recognize(componentResolver, parentComponent, u));
  return PromiseWrapper.all(recognized).then(ListWrapper.flatten);
}

function _constructSegment(componentResolver: ComponentResolver,
                           matched: _MatchResult): Promise<TreeNode<RouteSegment>[]> {
  return componentResolver.resolveComponent(matched.component)
      .then(factory => {
        let urlOutlet = matched.consumedUrlSegments.length === 0 ||
                                isBlank(matched.consumedUrlSegments[0].outlet) ?
                            DEFAULT_OUTLET_NAME :
                            matched.consumedUrlSegments[0].outlet;

        let segment = new RouteSegment(matched.consumedUrlSegments, matched.parameters, urlOutlet,
                                       factory.componentType, factory);

        if (matched.leftOverUrl.length > 0) {
          return _recognizeMany(componentResolver, factory.componentType, matched.leftOverUrl)
              .then(children => [new TreeNode<RouteSegment>(segment, children)]);
        } else {
          return _recognizeLeftOvers(componentResolver, factory.componentType)
              .then(children => [new TreeNode<RouteSegment>(segment, children)]);
        }
      });
}

function _recognizeLeftOvers(componentResolver: ComponentResolver,
                             parentComponent: Type): Promise<TreeNode<RouteSegment>[]> {
  return componentResolver.resolveComponent(parentComponent)
      .then(factory => {
        let metadata = _readMetadata(factory.componentType);
        if (isBlank(metadata)) {
          return [];
        }

        let r = (<any[]>metadata.routes).filter(r => r.path == "" || r.path == "/");
        if (r.length === 0) {
          return PromiseWrapper.resolve([]);
        } else {
          return _recognizeLeftOvers(componentResolver, r[0].component)
              .then(children => {
                return componentResolver.resolveComponent(r[0].component)
                    .then(factory => {
                      let segment =
                          new RouteSegment([], {}, DEFAULT_OUTLET_NAME, r[0].component, factory);
                      return [new TreeNode<RouteSegment>(segment, children)];
                    });
              });
        }
      });
}

function _match(metadata: RoutesMetadata, url: TreeNode<UrlSegment>): _MatchResult {
  for (let r of metadata.routes) {
    let matchingResult = _matchWithParts(r, url);
    if (isPresent(matchingResult)) {
      return matchingResult;
    }
  }
  let availableRoutes = metadata.routes.map(r => `'${r.path}'`).join(", ");
  throw new BaseException(
      `Cannot match any routes. Current segment: '${url.value}'. Available routes: [${availableRoutes}].`);
}

function _matchWithParts(route: RouteMetadata, url: TreeNode<UrlSegment>): _MatchResult {
  let path = route.path.startsWith("/") ? route.path.substring(1) : route.path;

  if (path == "*") {
    return new _MatchResult(route.component, [], null, [], []);
  }

  let parts = path.split("/");
  let positionalParams = {};
  let consumedUrlSegments = [];

  let lastParent: TreeNode<UrlSegment> = null;
  let lastSegment: TreeNode<UrlSegment> = null;

  let current = url;
  for (let i = 0; i < parts.length; ++i) {
    if (isBlank(current)) return null;

    let p = parts[i];
    let isLastSegment = i === parts.length - 1;
    let isLastParent = i === parts.length - 2;
    let isPosParam = p.startsWith(":");

    if (!isPosParam && p != current.value.segment) return null;
    if (isLastSegment) {
      lastSegment = current;
    }
    if (isLastParent) {
      lastParent = current;
    }

    if (isPosParam) {
      positionalParams[p.substring(1)] = current.value.segment;
    }

    consumedUrlSegments.push(current.value);

    current = ListWrapper.first(current.children);
  }

  let p = lastSegment.value.parameters;
  let parameters = <{[key: string]: string}>StringMapWrapper.merge(p, positionalParams);
  let axuUrlSubtrees = isPresent(lastParent) ? lastParent.children.slice(1) : [];

  return new _MatchResult(route.component, consumedUrlSegments, parameters, lastSegment.children,
                          axuUrlSubtrees);
}

function _checkOutletNameUniqueness(nodes: TreeNode<RouteSegment>[]): TreeNode<RouteSegment>[] {
  let names = {};
  nodes.forEach(n => {
    let segmentWithSameOutletName = names[n.value.outlet];
    if (isPresent(segmentWithSameOutletName)) {
      let p = segmentWithSameOutletName.stringifiedUrlSegments;
      let c = n.value.stringifiedUrlSegments;
      throw new BaseException(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
    }
    names[n.value.outlet] = n.value;
  });
  return nodes;
}

class _MatchResult {
  constructor(public component: Type|string, public consumedUrlSegments: UrlSegment[],
              public parameters: {[key: string]: string},
              public leftOverUrl: TreeNode<UrlSegment>[], public aux: TreeNode<UrlSegment>[]) {}
}

function _readMetadata(componentType: Type) {
  let metadata = reflector.annotations(componentType).filter(f => f instanceof RoutesMetadata);
  return ListWrapper.first(metadata);
}