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

cleanup(router): removes router

Browse Source
This commit is contained in:
vsavkin
2016-06-20 08:09:16 -07:00
parent 65be81baf8
commit af2f5c3d7d
65 changed files with 19 additions and 5172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,210 +0,0 @@
import {BaseException, ComponentFactory, ComponentResolver} from '@angular/core';
import {DEFAULT_OUTLET_NAME} from './constants';
import {reflector} from './core_private';
import {ListWrapper, StringMapWrapper} from './facade/collection';
import {Type, isBlank, isPresent, stringify} from './facade/lang';
import {PromiseWrapper} from './facade/promise';
import {RouteMetadata, RoutesMetadata} from './metadata/metadata';
import {RouteSegment, RouteTree, Tree, TreeNode, UrlSegment, UrlTree, equalUrlSegments, rootNode} from './segments';
export function recognize(
componentResolver: ComponentResolver, rootComponent: Type, url: UrlTree,
existingTree: RouteTree): Promise<RouteTree> {
let matched = new _MatchResult(rootComponent, [url.root], {}, rootNode(url).children, []);
return _constructSegment(componentResolver, matched, rootNode(existingTree))
.then(roots => new RouteTree(roots[0]));
}
function _recognize(
componentResolver: ComponentResolver, parentComponent: Type, 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(
`Component '${stringify(parentComponent)}' does not have route configuration`);
}
let match: any /** TODO #9100 */;
try {
match = _match(metadata, url);
} catch (e) {
return PromiseWrapper.reject(e, null);
}
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, existingSegments)
.then(_checkOutletNameUniqueness);
return PromiseWrapper.all([main, aux]).then(ListWrapper.flatten);
}
function _recognizeMany(
componentResolver: ComponentResolver, parentComponent: Type, 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,
existingSegment: TreeNode<RouteSegment>): Promise<TreeNode<RouteSegment>[]> {
return componentResolver.resolveComponent(matched.component).then(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, existingChildren)
.then(children => [new TreeNode<RouteSegment>(segment, children)]);
} else {
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,
existingSegments: TreeNode<RouteSegment>[]): 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 {
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 = _createOrReuseSegment(
new _MatchResult(r[0].component, [], {}, [], []), factory,
segmentWithMatchingOutlet);
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: any[] /** TODO #9100 */ = [];
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 as any /** TODO #9100 */)[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 as any /** TODO #9100 */)[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 as any /** TODO #9100 */)[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>[]) {}
get outlet(): string {
return this.consumedUrlSegments.length === 0 || isBlank(this.consumedUrlSegments[0].outlet) ?
DEFAULT_OUTLET_NAME :
this.consumedUrlSegments[0].outlet;
}
}
function _readMetadata(componentType: Type) {
let metadata = reflector.annotations(componentType).filter(f => f instanceof RoutesMetadata);
return ListWrapper.first(metadata);
}