cargdev/angular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(router): reuse existing segmentes when constructing new route trees

Browse Source
This commit is contained in:
vsavkin
2016-05-04 14:43:24 -07:00
parent b8136cc26e
commit abfb522f83
5 changed files with 94 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
modules/@angular/router/src/recognize.ts
View File

@ -1,21 +1,21 @@
import {RouteSegment, UrlSegment, Tree, TreeNode, rootNode, UrlTree, RouteTree} from './segments';
import {RouteSegment, UrlSegment, Tree, TreeNode, rootNode, UrlTree, RouteTree, equalUrlSegments} 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 {BaseException, ComponentFactory} 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> {
url: UrlTree, existingTree: RouteTree): Promise<RouteTree> {
let matched = new _MatchResult(rootComponent, [url.root], {}, rootNode(url).children, []);
return _constructSegment(componentResolver, matched).then(roots => new RouteTree(roots[0]));
return _constructSegment(componentResolver, matched, rootNode(existingTree)).then(roots => new RouteTree(roots[0]));
}
function _recognize(componentResolver: ComponentResolver, parentComponent: Type,
url: TreeNode<UrlSegment>): Promise<TreeNode<RouteSegment>[]> {
url: TreeNode<UrlSegment>, existingSegments: TreeNode<RouteSegment>[]): Promise<TreeNode<RouteSegment>[]> {
let metadata = _readMetadata(parentComponent); // should read from the factory instead
if (isBlank(metadata)) {
throw new BaseException(
@ -29,42 +29,53 @@ function _recognize(componentResolver: ComponentResolver, parentComponent: Type,
return PromiseWrapper.reject(e, null);
}
let main = _constructSegment(componentResolver, match);
let segmentsWithRightOutlet = existingSegments.filter(r => r.value.outlet == match.outlet);
let segmentWithRightOutlet = segmentsWithRightOutlet.length > 0 ? segmentsWithRightOutlet[0] : null;
let main = _constructSegment(componentResolver, match, segmentWithRightOutlet);
let aux =
_recognizeMany(componentResolver, parentComponent, match.aux).then(_checkOutletNameUniqueness);
_recognizeMany(componentResolver, parentComponent, match.aux, existingSegments).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));
urls: TreeNode<UrlSegment>[], existingSegments: TreeNode<RouteSegment>[]): Promise<TreeNode<RouteSegment>[]> {
let recognized = urls.map(u => _recognize(componentResolver, parentComponent, u, existingSegments));
return PromiseWrapper.all(recognized).then(ListWrapper.flatten);
}
function _constructSegment(componentResolver: ComponentResolver,
matched: _MatchResult): Promise<TreeNode<RouteSegment>[]> {
matched: _MatchResult, existingSegment: TreeNode<RouteSegment>): 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);
let segment = _createOrReuseSegment(matched, factory, existingSegment);
let existingChildren = isPresent(existingSegment) ? existingSegment.children : [];
if (matched.leftOverUrl.length > 0) {
return _recognizeMany(componentResolver, factory.componentType, matched.leftOverUrl)
return _recognizeMany(componentResolver, factory.componentType, matched.leftOverUrl, existingChildren)
.then(children => [new TreeNode<RouteSegment>(segment, children)]);
} else {
return _recognizeLeftOvers(componentResolver, factory.componentType)
return _recognizeLeftOvers(componentResolver, factory.componentType, existingChildren)
.then(children => [new TreeNode<RouteSegment>(segment, children)]);
}
});
}
function _createOrReuseSegment(matched: _MatchResult, factory: ComponentFactory<any>, segmentNode: TreeNode<RouteSegment>): RouteSegment {
let segment = isPresent(segmentNode) ? segmentNode.value : null;
if (isPresent(segment) && equalUrlSegments(segment.urlSegments, matched.consumedUrlSegments)
&& StringMapWrapper.equals(segment.parameters, matched.parameters) &&
segment.outlet == matched.outlet && factory.componentType == segment.type) {
return segment;
} else {
return new RouteSegment(matched.consumedUrlSegments, matched.parameters, matched.outlet,
factory.componentType, factory);
}
}
function _recognizeLeftOvers(componentResolver: ComponentResolver,
parentComponent: Type): Promise<TreeNode<RouteSegment>[]> {
parentComponent: Type, existingSegments: TreeNode<RouteSegment>[]): Promise<TreeNode<RouteSegment>[]> {
return componentResolver.resolveComponent(parentComponent)
.then(factory => {
let metadata = _readMetadata(factory.componentType);
@ -76,12 +87,14 @@ function _recognizeLeftOvers(componentResolver: ComponentResolver,
if (r.length === 0) {
return PromiseWrapper.resolve([]);
} else {
return _recognizeLeftOvers(componentResolver, r[0].component)
.then(children => {
let segmentsWithMatchingOutlet = existingSegments.filter(r => r.value.outlet == DEFAULT_OUTLET_NAME);
let segmentWithMatchingOutlet = segmentsWithMatchingOutlet.length > 0 ? segmentsWithMatchingOutlet[0] : null;
let existingChildren = isPresent(segmentWithMatchingOutlet) ? segmentWithMatchingOutlet.children : [];
return _recognizeLeftOvers(componentResolver, r[0].component, existingChildren).then(children => {
return componentResolver.resolveComponent(r[0].component)
.then(factory => {
let segment =
new RouteSegment([], {}, DEFAULT_OUTLET_NAME, r[0].component, factory);
let segment = _createOrReuseSegment(new _MatchResult(r[0].component, [], {}, [], []), factory, segmentWithMatchingOutlet);
return [new TreeNode<RouteSegment>(segment, children)];
});
});
@ -167,6 +180,13 @@ class _MatchResult {
constructor(public component: Type|string, public consumedUrlSegments: UrlSegment[],
public parameters: {[key: string]: string},
public leftOverUrl: TreeNode<UrlSegment>[], public aux: TreeNode<UrlSegment>[]) {}
get outlet():string {
return this.consumedUrlSegments.length === 0 ||
isBlank(this.consumedUrlSegments[0].outlet) ?
DEFAULT_OUTLET_NAME :
this.consumedUrlSegments[0].outlet;
}
}
function _readMetadata(componentType: Type) {