angular2
Version:
Angular 2 - a web framework for modern web apps
288 lines • 30.6 kB
JavaScript
import { StringMapWrapper } from 'angular2/src/facade/collection';
import { isPresent, isBlank, normalizeBlank, CONST_EXPR } from 'angular2/src/facade/lang';
import { PromiseWrapper } from 'angular2/src/facade/async';
/**
* `RouteParams` is an immutable map of parameters for the given route
* based on the url matcher and optional parameters for that route.
*
* You can inject `RouteParams` into the constructor of a component to use it.
*
* ### Example
*
* ```
* import {Component} from 'angular2/core';
* import {bootstrap} from 'angular2/platform/browser';
* import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig, RouteParams} from
* 'angular2/router';
*
* @Component({directives: [ROUTER_DIRECTIVES]})
* @RouteConfig([
* {path: '/user/:id', component: UserCmp, name: 'UserCmp'},
* ])
* class AppCmp {}
*
* @Component({ template: 'user: {{id}}' })
* class UserCmp {
* id: string;
* constructor(params: RouteParams) {
* this.id = params.get('id');
* }
* }
*
* bootstrap(AppCmp, ROUTER_PROVIDERS);
* ```
*/
export class RouteParams {
constructor(params) {
this.params = params;
}
get(param) { return normalizeBlank(StringMapWrapper.get(this.params, param)); }
}
/**
* `RouteData` is an immutable map of additional data you can configure in your {@link Route}.
*
* You can inject `RouteData` into the constructor of a component to use it.
*
* ### Example
*
* ```
* import {Component} from 'angular2/core';
* import {bootstrap} from 'angular2/platform/browser';
* import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig, RouteData} from
* 'angular2/router';
*
* @Component({directives: [ROUTER_DIRECTIVES]})
* @RouteConfig([
* {path: '/user/:id', component: UserCmp, name: 'UserCmp', data: {isAdmin: true}},
* ])
* class AppCmp {}
*
* @Component({
* ...,
* template: 'user: {{isAdmin}}'
* })
* class UserCmp {
* string: isAdmin;
* constructor(data: RouteData) {
* this.isAdmin = data.get('isAdmin');
* }
* }
*
* bootstrap(AppCmp, ROUTER_PROVIDERS);
* ```
*/
export class RouteData {
constructor(data = CONST_EXPR({})) {
this.data = data;
}
get(key) { return normalizeBlank(StringMapWrapper.get(this.data, key)); }
}
export var BLANK_ROUTE_DATA = new RouteData();
/**
* `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed
* to transition each component in the app to a given route, including all auxiliary routes.
*
* `Instruction`s can be created using {@link Router#generate}, and can be used to
* perform route changes with {@link Router#navigateByInstruction}.
*
* ### Example
*
* ```
* import {Component} from 'angular2/core';
* import {bootstrap} from 'angular2/platform/browser';
* import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
*
* @Component({directives: [ROUTER_DIRECTIVES]})
* @RouteConfig([
* {...},
* ])
* class AppCmp {
* constructor(router: Router) {
* var instruction = router.generate(['/MyRoute']);
* router.navigateByInstruction(instruction);
* }
* }
*
* bootstrap(AppCmp, ROUTER_PROVIDERS);
* ```
*/
export class Instruction {
constructor(component, child, auxInstruction) {
this.component = component;
this.child = child;
this.auxInstruction = auxInstruction;
}
get urlPath() { return isPresent(this.component) ? this.component.urlPath : ''; }
get urlParams() { return isPresent(this.component) ? this.component.urlParams : []; }
get specificity() {
var total = '';
if (isPresent(this.component)) {
total += this.component.specificity;
}
if (isPresent(this.child)) {
total += this.child.specificity;
}
return total;
}
/**
* converts the instruction into a URL string
*/
toRootUrl() { return this.toUrlPath() + this.toUrlQuery(); }
/** @internal */
_toNonRootUrl() {
return this._stringifyPathMatrixAuxPrefixed() +
(isPresent(this.child) ? this.child._toNonRootUrl() : '');
}
toUrlQuery() { return this.urlParams.length > 0 ? ('?' + this.urlParams.join('&')) : ''; }
/**
* Returns a new instruction that shares the state of the existing instruction, but with
* the given child {@link Instruction} replacing the existing child.
*/
replaceChild(child) {
return new ResolvedInstruction(this.component, child, this.auxInstruction);
}
/**
* If the final URL for the instruction is ``
*/
toUrlPath() {
return this.urlPath + this._stringifyAux() +
(isPresent(this.child) ? this.child._toNonRootUrl() : '');
}
// default instructions override these
toLinkUrl() {
return this.urlPath + this._stringifyAux() +
(isPresent(this.child) ? this.child._toLinkUrl() : '') + this.toUrlQuery();
}
// this is the non-root version (called recursively)
/** @internal */
_toLinkUrl() {
return this._stringifyPathMatrixAuxPrefixed() +
(isPresent(this.child) ? this.child._toLinkUrl() : '');
}
/** @internal */
_stringifyPathMatrixAuxPrefixed() {
var primary = this._stringifyPathMatrixAux();
if (primary.length > 0) {
primary = '/' + primary;
}
return primary;
}
/** @internal */
_stringifyMatrixParams() {
return this.urlParams.length > 0 ? (';' + this.urlParams.join(';')) : '';
}
/** @internal */
_stringifyPathMatrixAux() {
if (isBlank(this.component)) {
return '';
}
return this.urlPath + this._stringifyMatrixParams() + this._stringifyAux();
}
/** @internal */
_stringifyAux() {
var routes = [];
StringMapWrapper.forEach(this.auxInstruction, (auxInstruction, _) => {
routes.push(auxInstruction._stringifyPathMatrixAux());
});
if (routes.length > 0) {
return '(' + routes.join('//') + ')';
}
return '';
}
}
/**
* a resolved instruction has an outlet instruction for itself, but maybe not for...
*/
export class ResolvedInstruction extends Instruction {
constructor(component, child, auxInstruction) {
super(component, child, auxInstruction);
}
resolveComponent() {
return PromiseWrapper.resolve(this.component);
}
}
/**
* Represents a resolved default route
*/
export class DefaultInstruction extends ResolvedInstruction {
constructor(component, child) {
super(component, child, {});
}
toLinkUrl() { return ''; }
/** @internal */
_toLinkUrl() { return ''; }
}
/**
* Represents a component that may need to do some redirection or lazy loading at a later time.
*/
export class UnresolvedInstruction extends Instruction {
constructor(_resolver, _urlPath = '', _urlParams = CONST_EXPR([])) {
super(null, null, {});
this._resolver = _resolver;
this._urlPath = _urlPath;
this._urlParams = _urlParams;
}
get urlPath() {
if (isPresent(this.component)) {
return this.component.urlPath;
}
if (isPresent(this._urlPath)) {
return this._urlPath;
}
return '';
}
get urlParams() {
if (isPresent(this.component)) {
return this.component.urlParams;
}
if (isPresent(this._urlParams)) {
return this._urlParams;
}
return [];
}
resolveComponent() {
if (isPresent(this.component)) {
return PromiseWrapper.resolve(this.component);
}
return this._resolver().then((instruction) => {
this.child = isPresent(instruction) ? instruction.child : null;
return this.component = isPresent(instruction) ? instruction.component : null;
});
}
}
export class RedirectInstruction extends ResolvedInstruction {
constructor(component, child, auxInstruction, _specificity) {
super(component, child, auxInstruction);
this._specificity = _specificity;
}
get specificity() { return this._specificity; }
}
/**
* A `ComponentInstruction` represents the route state for a single component.
*
* `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
* to route lifecycle hooks, like {@link CanActivate}.
*
* `ComponentInstruction`s are [hash consed](https://en.wikipedia.org/wiki/Hash_consing). You should
* never construct one yourself with "new." Instead, rely on router's internal recognizer to
* construct `ComponentInstruction`s.
*
* You should not modify this object. It should be treated as immutable.
*/
export class ComponentInstruction {
/**
* @internal
*/
constructor(urlPath, urlParams, data, componentType, terminal, specificity, params = null, routeName) {
this.urlPath = urlPath;
this.urlParams = urlParams;
this.componentType = componentType;
this.terminal = terminal;
this.specificity = specificity;
this.params = params;
this.routeName = routeName;
this.reuse = false;
this.routeData = isPresent(data) ? data : BLANK_ROUTE_DATA;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instruction.js","sourceRoot":"","sources":["diffing_plugin_wrapper-output_path-xBLIBrVR.tmp/angular2/src/router/instruction.ts"],"names":[],"mappings":"OAAO,EAAkB,gBAAgB,EAAc,MAAM,gCAAgC;OACtF,EAAC,SAAS,EAAE,OAAO,EAAE,cAAc,EAAQ,UAAU,EAAC,MAAM,0BAA0B;OACtF,EAAC,cAAc,EAAC,MAAM,2BAA2B;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IACE,YAAmB,MAA+B;QAA/B,WAAM,GAAN,MAAM,CAAyB;IAAG,CAAC;IAEtD,GAAG,CAAC,KAAa,IAAY,MAAM,CAAC,cAAc,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACjG,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACE,YAAmB,IAAI,GAAyB,UAAU,CAAC,EAAE,CAAC;QAA3C,SAAI,GAAJ,IAAI,CAAuC;IAAG,CAAC;IAElE,GAAG,CAAC,GAAW,IAAS,MAAM,CAAC,cAAc,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACxF,CAAC;AAED,OAAO,IAAI,gBAAgB,GAAG,IAAI,SAAS,EAAE,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACE,YAAmB,SAA+B,EAAS,KAAkB,EAC1D,cAA4C;QAD5C,cAAS,GAAT,SAAS,CAAsB;QAAS,UAAK,GAAL,KAAK,CAAa;QAC1D,mBAAc,GAAd,cAAc,CAA8B;IAAG,CAAC;IAEnE,IAAI,OAAO,KAAa,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC,CAAC;IAEzF,IAAI,SAAS,KAAe,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC;IAE/F,IAAI,WAAW;QACb,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC9B,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;QACtC,CAAC;QACD,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC1B,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;QAClC,CAAC;QACD,MAAM,CAAC,KAAK,CAAC;IACf,CAAC;IAID;;OAEG;IACH,SAAS,KAAa,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAEpE,gBAAgB;IAChB,aAAa;QACX,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE;YACtC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,GAAG,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,UAAU,KAAa,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAElG;;;OAGG;IACH,YAAY,CAAC,KAAkB;QAC7B,MAAM,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC7E,CAAC;IAED;;OAEG;IACH,SAAS;QACP,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE;YACnC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,GAAG,EAAE,CAAC,CAAC;IACnE,CAAC;IAED,sCAAsC;IACtC,SAAS;QACP,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE;YACnC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;IACpF,CAAC;IAED,oDAAoD;IACpD,gBAAgB;IAChB,UAAU;QACR,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE;YACtC,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,gBAAgB;IAChB,+BAA+B;QAC7B,IAAI,OAAO,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC7C,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YACvB,OAAO,GAAG,GAAG,GAAG,OAAO,CAAC;QAC1B,CAAC;QACD,MAAM,CAAC,OAAO,CAAC;IACjB,CAAC;IAED,gBAAgB;IAChB,sBAAsB;QACpB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;IAC3E,CAAC;IAED,gBAAgB;IAChB,uBAAuB;QACrB,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,CAAC,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,sBAAsB,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;IAC7E,CAAC;IAED,gBAAgB;IAChB,aAAa;QACX,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,cAA2B,EAAE,CAAS;YACnF,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,uBAAuB,EAAE,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YACtB,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;QACvC,CAAC;QACD,MAAM,CAAC,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAGD;;GAEG;AACH,yCAAyC,WAAW;IAClD,YAAY,SAA+B,EAAE,KAAkB,EACnD,cAA4C;QACtD,MAAM,SAAS,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;IAC1C,CAAC;IAED,gBAAgB;QACd,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAGD;;GAEG;AACH,wCAAwC,mBAAmB;IACzD,YAAY,SAA+B,EAAE,KAAyB;QACpE,MAAM,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,SAAS,KAAa,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;IAElC,gBAAgB;IAChB,UAAU,KAAa,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;AACrC,CAAC;AAGD;;GAEG;AACH,2CAA2C,WAAW;IACpD,YAAoB,SAAqC,EAAU,QAAQ,GAAW,EAAE,EACpE,UAAU,GAAa,UAAU,CAAC,EAAE,CAAC;QACvD,MAAM,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QAFJ,cAAS,GAAT,SAAS,CAA4B;QAAU,aAAQ,GAAR,QAAQ,CAAa;QACpE,eAAU,GAAV,UAAU,CAA2B;IAEzD,CAAC;IAED,IAAI,OAAO;QACT,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;QAChC,CAAC;QACD,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC7B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;QACD,MAAM,CAAC,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,SAAS;QACX,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;QAClC,CAAC;QACD,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;QACD,MAAM,CAAC,EAAE,CAAC;IACZ,CAAC;IAED,gBAAgB;QACd,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC9B,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,WAAwB;YACpD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,KAAK,GAAG,IAAI,CAAC;YAC/D,MAAM,CAAC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC;QAChF,CAAC,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAGD,yCAAyC,mBAAmB;IAC1D,YAAY,SAA+B,EAAE,KAAkB,EACnD,cAA4C,EAAU,YAAoB;QACpF,MAAM,SAAS,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;QADwB,iBAAY,GAAZ,YAAY,CAAQ;IAEtF,CAAC;IAED,IAAI,WAAW,KAAa,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;AACzD,CAAC;AAGD;;;;;;;;;;;GAWG;AACH;IAIE;;OAEG;IACH,YAAmB,OAAe,EAAS,SAAmB,EAAE,IAAe,EAC5D,aAAa,EAAS,QAAiB,EAAS,WAAmB,EACnE,MAAM,GAA4B,IAAI,EAAS,SAAiB;QAFhE,YAAO,GAAP,OAAO,CAAQ;QAAS,cAAS,GAAT,SAAS,CAAU;QAC3C,kBAAa,GAAb,aAAa,CAAA;QAAS,aAAQ,GAAR,QAAQ,CAAS;QAAS,gBAAW,GAAX,WAAW,CAAQ;QACnE,WAAM,GAAN,MAAM,CAAgC;QAAS,cAAS,GAAT,SAAS,CAAQ;QARnF,UAAK,GAAY,KAAK,CAAC;QASrB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,gBAAgB,CAAC;IAC7D,CAAC;AACH,CAAC;AAAA","sourcesContent":["import {Map, MapWrapper, StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';\nimport {isPresent, isBlank, normalizeBlank, Type, CONST_EXPR} from 'angular2/src/facade/lang';\nimport {PromiseWrapper} from 'angular2/src/facade/async';\n\n\n/**\n * `RouteParams` is an immutable map of parameters for the given route\n * based on the url matcher and optional parameters for that route.\n *\n * You can inject `RouteParams` into the constructor of a component to use it.\n *\n * ### Example\n *\n * ```\n * import {Component} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig, RouteParams} from\n * 'angular2/router';\n *\n * @Component({directives: [ROUTER_DIRECTIVES]})\n * @RouteConfig([\n *  {path: '/user/:id', component: UserCmp, name: 'UserCmp'},\n * ])\n * class AppCmp {}\n *\n * @Component({ template: 'user: {{id}}' })\n * class UserCmp {\n *   id: string;\n *   constructor(params: RouteParams) {\n *     this.id = params.get('id');\n *   }\n * }\n *\n * bootstrap(AppCmp, ROUTER_PROVIDERS);\n * ```\n */\nexport class RouteParams {\n  constructor(public params: {[key: string]: string}) {}\n\n  get(param: string): string { return normalizeBlank(StringMapWrapper.get(this.params, param)); }\n}\n\n/**\n * `RouteData` is an immutable map of additional data you can configure in your {@link Route}.\n *\n * You can inject `RouteData` into the constructor of a component to use it.\n *\n * ### Example\n *\n * ```\n * import {Component} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig, RouteData} from\n * 'angular2/router';\n *\n * @Component({directives: [ROUTER_DIRECTIVES]})\n * @RouteConfig([\n *  {path: '/user/:id', component: UserCmp, name: 'UserCmp', data: {isAdmin: true}},\n * ])\n * class AppCmp {}\n *\n * @Component({\n *   ...,\n *   template: 'user: {{isAdmin}}'\n * })\n * class UserCmp {\n *   string: isAdmin;\n *   constructor(data: RouteData) {\n *     this.isAdmin = data.get('isAdmin');\n *   }\n * }\n *\n * bootstrap(AppCmp, ROUTER_PROVIDERS);\n * ```\n */\nexport class RouteData {\n  constructor(public data: {[key: string]: any} = CONST_EXPR({})) {}\n\n  get(key: string): any { return normalizeBlank(StringMapWrapper.get(this.data, key)); }\n}\n\nexport var BLANK_ROUTE_DATA = new RouteData();\n\n/**\n * `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed\n * to transition each component in the app to a given route, including all auxiliary routes.\n *\n * `Instruction`s can be created using {@link Router#generate}, and can be used to\n * perform route changes with {@link Router#navigateByInstruction}.\n *\n * ### Example\n *\n * ```\n * import {Component} from 'angular2/core';\n * import {bootstrap} from 'angular2/platform/browser';\n * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';\n *\n * @Component({directives: [ROUTER_DIRECTIVES]})\n * @RouteConfig([\n *  {...},\n * ])\n * class AppCmp {\n *   constructor(router: Router) {\n *     var instruction = router.generate(['/MyRoute']);\n *     router.navigateByInstruction(instruction);\n *   }\n * }\n *\n * bootstrap(AppCmp, ROUTER_PROVIDERS);\n * ```\n */\nexport abstract class Instruction {\n  constructor(public component: ComponentInstruction, public child: Instruction,\n              public auxInstruction: {[key: string]: Instruction}) {}\n\n  get urlPath(): string { return isPresent(this.component) ? this.component.urlPath : ''; }\n\n  get urlParams(): string[] { return isPresent(this.component) ? this.component.urlParams : []; }\n\n  get specificity(): string {\n    var total = '';\n    if (isPresent(this.component)) {\n      total += this.component.specificity;\n    }\n    if (isPresent(this.child)) {\n      total += this.child.specificity;\n    }\n    return total;\n  }\n\n  abstract resolveComponent(): Promise<ComponentInstruction>;\n\n  /**\n   * converts the instruction into a URL string\n   */\n  toRootUrl(): string { return this.toUrlPath() + this.toUrlQuery(); }\n\n  /** @internal */\n  _toNonRootUrl(): string {\n    return this._stringifyPathMatrixAuxPrefixed() +\n           (isPresent(this.child) ? this.child._toNonRootUrl() : '');\n  }\n\n  toUrlQuery(): string { return this.urlParams.length > 0 ? ('?' + this.urlParams.join('&')) : ''; }\n\n  /**\n   * Returns a new instruction that shares the state of the existing instruction, but with\n   * the given child {@link Instruction} replacing the existing child.\n   */\n  replaceChild(child: Instruction): Instruction {\n    return new ResolvedInstruction(this.component, child, this.auxInstruction);\n  }\n\n  /**\n   * If the final URL for the instruction is ``\n   */\n  toUrlPath(): string {\n    return this.urlPath + this._stringifyAux() +\n           (isPresent(this.child) ? this.child._toNonRootUrl() : '');\n  }\n\n  // default instructions override these\n  toLinkUrl(): string {\n    return this.urlPath + this._stringifyAux() +\n           (isPresent(this.child) ? this.child._toLinkUrl() : '') + this.toUrlQuery();\n  }\n\n  // this is the non-root version (called recursively)\n  /** @internal */\n  _toLinkUrl(): string {\n    return this._stringifyPathMatrixAuxPrefixed() +\n           (isPresent(this.child) ? this.child._toLinkUrl() : '');\n  }\n\n  /** @internal */\n  _stringifyPathMatrixAuxPrefixed(): string {\n    var primary = this._stringifyPathMatrixAux();\n    if (primary.length > 0) {\n      primary = '/' + primary;\n    }\n    return primary;\n  }\n\n  /** @internal */\n  _stringifyMatrixParams(): string {\n    return this.urlParams.length > 0 ? (';' + this.urlParams.join(';')) : '';\n  }\n\n  /** @internal */\n  _stringifyPathMatrixAux(): string {\n    if (isBlank(this.component)) {\n      return '';\n    }\n    return this.urlPath + this._stringifyMatrixParams() + this._stringifyAux();\n  }\n\n  /** @internal */\n  _stringifyAux(): string {\n    var routes = [];\n    StringMapWrapper.forEach(this.auxInstruction, (auxInstruction: Instruction, _: string) => {\n      routes.push(auxInstruction._stringifyPathMatrixAux());\n    });\n    if (routes.length > 0) {\n      return '(' + routes.join('//') + ')';\n    }\n    return '';\n  }\n}\n\n\n/**\n * a resolved instruction has an outlet instruction for itself, but maybe not for...\n */\nexport class ResolvedInstruction extends Instruction {\n  constructor(component: ComponentInstruction, child: Instruction,\n              auxInstruction: {[key: string]: Instruction}) {\n    super(component, child, auxInstruction);\n  }\n\n  resolveComponent(): Promise<ComponentInstruction> {\n    return PromiseWrapper.resolve(this.component);\n  }\n}\n\n\n/**\n * Represents a resolved default route\n */\nexport class DefaultInstruction extends ResolvedInstruction {\n  constructor(component: ComponentInstruction, child: DefaultInstruction) {\n    super(component, child, {});\n  }\n\n  toLinkUrl(): string { return ''; }\n\n  /** @internal */\n  _toLinkUrl(): string { return ''; }\n}\n\n\n/**\n * Represents a component that may need to do some redirection or lazy loading at a later time.\n */\nexport class UnresolvedInstruction extends Instruction {\n  constructor(private _resolver: () => Promise<Instruction>, private _urlPath: string = '',\n              private _urlParams: string[] = CONST_EXPR([])) {\n    super(null, null, {});\n  }\n\n  get urlPath(): string {\n    if (isPresent(this.component)) {\n      return this.component.urlPath;\n    }\n    if (isPresent(this._urlPath)) {\n      return this._urlPath;\n    }\n    return '';\n  }\n\n  get urlParams(): string[] {\n    if (isPresent(this.component)) {\n      return this.component.urlParams;\n    }\n    if (isPresent(this._urlParams)) {\n      return this._urlParams;\n    }\n    return [];\n  }\n\n  resolveComponent(): Promise<ComponentInstruction> {\n    if (isPresent(this.component)) {\n      return PromiseWrapper.resolve(this.component);\n    }\n    return this._resolver().then((instruction: Instruction) => {\n      this.child = isPresent(instruction) ? instruction.child : null;\n      return this.component = isPresent(instruction) ? instruction.component : null;\n    });\n  }\n}\n\n\nexport class RedirectInstruction extends ResolvedInstruction {\n  constructor(component: ComponentInstruction, child: Instruction,\n              auxInstruction: {[key: string]: Instruction}, private _specificity: string) {\n    super(component, child, auxInstruction);\n  }\n\n  get specificity(): string { return this._specificity; }\n}\n\n\n/**\n * A `ComponentInstruction` represents the route state for a single component.\n *\n * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed\n * to route lifecycle hooks, like {@link CanActivate}.\n *\n * `ComponentInstruction`s are [hash consed](https://en.wikipedia.org/wiki/Hash_consing). You should\n * never construct one yourself with \"new.\" Instead, rely on router's internal recognizer to\n * construct `ComponentInstruction`s.\n *\n * You should not modify this object. It should be treated as immutable.\n */\nexport class ComponentInstruction {\n  reuse: boolean = false;\n  public routeData: RouteData;\n\n  /**\n   * @internal\n   */\n  constructor(public urlPath: string, public urlParams: string[], data: RouteData,\n              public componentType, public terminal: boolean, public specificity: string,\n              public params: {[key: string]: string} = null, public routeName: string) {\n    this.routeData = isPresent(data) ? data : BLANK_ROUTE_DATA;\n  }\n}\n"]}