@angular/router-deprecated
Version:
122 lines • 5.19 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var collection_1 = require('../facade/collection');
var exceptions_1 = require('../facade/exceptions');
var lang_1 = require('../facade/lang');
var promise_1 = require('../facade/promise');
var instruction_1 = require('../instruction');
var url_parser_1 = require('../url_parser');
// RouteMatch objects hold information about a match between a rule and a URL
var RouteMatch = (function () {
function RouteMatch() {
}
return RouteMatch;
}());
exports.RouteMatch = RouteMatch;
var PathMatch = (function (_super) {
__extends(PathMatch, _super);
function PathMatch(instruction, remaining, remainingAux) {
_super.call(this);
this.instruction = instruction;
this.remaining = remaining;
this.remainingAux = remainingAux;
}
return PathMatch;
}(RouteMatch));
exports.PathMatch = PathMatch;
var RedirectMatch = (function (_super) {
__extends(RedirectMatch, _super);
function RedirectMatch(redirectTo, specificity /** TODO #9100 */) {
_super.call(this);
this.redirectTo = redirectTo;
this.specificity = specificity;
}
return RedirectMatch;
}(RouteMatch));
exports.RedirectMatch = RedirectMatch;
var RedirectRule = (function () {
function RedirectRule(_pathRecognizer, redirectTo) {
this._pathRecognizer = _pathRecognizer;
this.redirectTo = redirectTo;
this.hash = this._pathRecognizer.hash;
}
Object.defineProperty(RedirectRule.prototype, "path", {
get: function () { return this._pathRecognizer.toString(); },
set: function (val) { throw new exceptions_1.BaseException('you cannot set the path of a RedirectRule directly'); },
enumerable: true,
configurable: true
});
/**
* Returns `null` or a `ParsedUrl` representing the new path to match
*/
RedirectRule.prototype.recognize = function (beginningSegment) {
var match = null;
if (lang_1.isPresent(this._pathRecognizer.matchUrl(beginningSegment))) {
match = new RedirectMatch(this.redirectTo, this._pathRecognizer.specificity);
}
return promise_1.PromiseWrapper.resolve(match);
};
RedirectRule.prototype.generate = function (params) {
throw new exceptions_1.BaseException("Tried to generate a redirect.");
};
return RedirectRule;
}());
exports.RedirectRule = RedirectRule;
// represents something like '/foo/:bar'
var RouteRule = (function () {
// TODO: cache component instruction instances by params and by ParsedUrl instance
function RouteRule(_routePath, handler, _routeName) {
this._routePath = _routePath;
this.handler = handler;
this._routeName = _routeName;
this._cache = new collection_1.Map();
this.specificity = this._routePath.specificity;
this.hash = this._routePath.hash;
this.terminal = this._routePath.terminal;
}
Object.defineProperty(RouteRule.prototype, "path", {
get: function () { return this._routePath.toString(); },
set: function (val) { throw new exceptions_1.BaseException('you cannot set the path of a RouteRule directly'); },
enumerable: true,
configurable: true
});
RouteRule.prototype.recognize = function (beginningSegment) {
var _this = this;
var res = this._routePath.matchUrl(beginningSegment);
if (lang_1.isBlank(res)) {
return null;
}
return this.handler.resolveComponentType().then(function (_) {
var componentInstruction = _this._getInstruction(res.urlPath, res.urlParams, res.allParams);
return new PathMatch(componentInstruction, res.rest, res.auxiliary);
});
};
RouteRule.prototype.generate = function (params) {
var generated = this._routePath.generateUrl(params);
var urlPath = generated.urlPath;
var urlParams = generated.urlParams;
return this._getInstruction(urlPath, url_parser_1.convertUrlParamsToArray(urlParams), params);
};
RouteRule.prototype.generateComponentPathValues = function (params) {
return this._routePath.generateUrl(params);
};
RouteRule.prototype._getInstruction = function (urlPath, urlParams, params) {
if (lang_1.isBlank(this.handler.componentType)) {
throw new exceptions_1.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 instruction_1.ComponentInstruction(urlPath, urlParams, this.handler.data, this.handler.componentType, this.terminal, this.specificity, params, this._routeName);
this._cache.set(hashKey, instruction);
return instruction;
};
return RouteRule;
}());
exports.RouteRule = RouteRule;
//# sourceMappingURL=rules.js.map