@angular/router-deprecated
Version:
93 lines • 3.82 kB
JavaScript
import { Map } from '../facade/collection';
import { BaseException } from '../facade/exceptions';
import { isBlank, isPresent } from '../facade/lang';
import { PromiseWrapper } from '../facade/promise';
import { ComponentInstruction } from '../instruction';
import { convertUrlParamsToArray } from '../url_parser';
// RouteMatch objects hold information about a match between a rule and a URL
export class RouteMatch {
}
export class PathMatch extends RouteMatch {
constructor(instruction, remaining, remainingAux) {
super();
this.instruction = instruction;
this.remaining = remaining;
this.remainingAux = remainingAux;
}
}
export class RedirectMatch extends RouteMatch {
constructor(redirectTo, specificity /** TODO #9100 */) {
super();
this.redirectTo = redirectTo;
this.specificity = specificity;
}
}
export class RedirectRule {
constructor(_pathRecognizer, redirectTo) {
this._pathRecognizer = _pathRecognizer;
this.redirectTo = redirectTo;
this.hash = this._pathRecognizer.hash;
}
get path() { return this._pathRecognizer.toString(); }
set path(val) { throw new BaseException('you cannot set the path of a RedirectRule directly'); }
/**
* Returns `null` or a `ParsedUrl` representing the new path to match
*/
recognize(beginningSegment) {
var match = null;
if (isPresent(this._pathRecognizer.matchUrl(beginningSegment))) {
match = new RedirectMatch(this.redirectTo, this._pathRecognizer.specificity);
}
return PromiseWrapper.resolve(match);
}
generate(params) {
throw new BaseException(`Tried to generate a redirect.`);
}
}
// represents something like '/foo/:bar'
export class RouteRule {
// TODO: cache component instruction instances by params and by ParsedUrl instance
constructor(_routePath, handler, _routeName) {
this._routePath = _routePath;
this.handler = handler;
this._routeName = _routeName;
this._cache = new Map();
this.specificity = this._routePath.specificity;
this.hash = this._routePath.hash;
this.terminal = this._routePath.terminal;
}
get path() { return this._routePath.toString(); }
set path(val) { throw new BaseException('you cannot set the path of a RouteRule directly'); }
recognize(beginningSegment) {
var res = this._routePath.matchUrl(beginningSegment);
if (isBlank(res)) {
return null;
}
return this.handler.resolveComponentType().then((_) => {
var componentInstruction = this._getInstruction(res.urlPath, res.urlParams, res.allParams);
return new PathMatch(componentInstruction, res.rest, res.auxiliary);
});
}
generate(params) {
var generated = this._routePath.generateUrl(params);
var urlPath = generated.urlPath;
var urlParams = generated.urlParams;
return this._getInstruction(urlPath, convertUrlParamsToArray(urlParams), params);
}
generateComponentPathValues(params) {
return this._routePath.generateUrl(params);
}
_getInstruction(urlPath, urlParams, params) {
if (isBlank(this.handler.componentType)) {
throw new BaseException(`Tried to get instruction before the type was loaded.`);
}
var hashKey = urlPath + '?' + urlParams.join('&');
if (this._cache.has(hashKey)) {
return this._cache.get(hashKey);
}
var instruction = new ComponentInstruction(urlPath, urlParams, this.handler.data, this.handler.componentType, this.terminal, this.specificity, params, this._routeName);
this._cache.set(hashKey, instruction);
return instruction;
}
}
//# sourceMappingURL=rules.js.map