mirror of
https://github.com/ionic-team/ionic-framework.git
synced 2025-08-18 19:21:34 +08:00
7551 lines
256 KiB
JavaScript
7551 lines
256 KiB
JavaScript
/**
|
|
* @license Angular v6.0.0-beta.2-8c5c0dac1
|
|
* (c) 2010-2018 Google, Inc. https://angular.io/
|
|
* License: MIT
|
|
*/
|
|
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common'), require('@angular/core'), require('rxjs/BehaviorSubject'), require('rxjs/Subject'), require('rxjs/observable/of'), require('rxjs/operator/concatMap'), require('rxjs/operator/map'), require('rxjs/operator/mergeMap'), require('rxjs/Observable'), require('rxjs/observable/from'), require('rxjs/operator/catch'), require('rxjs/operator/concatAll'), require('rxjs/operator/first'), require('rxjs/util/EmptyError'), require('rxjs/observable/fromPromise'), require('rxjs/operator/every'), require('rxjs/operator/last'), require('rxjs/operator/mergeAll'), require('rxjs/operator/reduce'), require('@angular/platform-browser'), require('rxjs/operator/filter')) :
|
|
typeof define === 'function' && define.amd ? define('@angular/router', ['exports', '@angular/common', '@angular/core', 'rxjs/BehaviorSubject', 'rxjs/Subject', 'rxjs/observable/of', 'rxjs/operator/concatMap', 'rxjs/operator/map', 'rxjs/operator/mergeMap', 'rxjs/Observable', 'rxjs/observable/from', 'rxjs/operator/catch', 'rxjs/operator/concatAll', 'rxjs/operator/first', 'rxjs/util/EmptyError', 'rxjs/observable/fromPromise', 'rxjs/operator/every', 'rxjs/operator/last', 'rxjs/operator/mergeAll', 'rxjs/operator/reduce', '@angular/platform-browser', 'rxjs/operator/filter'], factory) :
|
|
(factory((global.ng = global.ng || {}, global.ng.router = {}),global.ng.common,global.ng.core,global.Rx,global.Rx,global.Rx.Observable,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.Rx,global.Rx.Observable,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.Rx,global.Rx.Observable,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.Rx.Observable.prototype,global.ng.platformBrowser,global.Rx.Observable.prototype));
|
|
}(this, (function (exports,_angular_common,_angular_core,rxjs_BehaviorSubject,rxjs_Subject,rxjs_observable_of,rxjs_operator_concatMap,rxjs_operator_map,rxjs_operator_mergeMap,rxjs_Observable,rxjs_observable_from,rxjs_operator_catch,rxjs_operator_concatAll,rxjs_operator_first,rxjs_util_EmptyError,rxjs_observable_fromPromise,rxjs_operator_every,rxjs_operator_last,rxjs_operator_mergeAll,rxjs_operator_reduce,_angular_platformBrowser,rxjs_operator_filter) { 'use strict';
|
|
|
|
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
/* global Reflect, Promise */
|
|
|
|
var extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
|
|
function __extends(d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
}
|
|
|
|
var __assign = Object.assign || function __assign(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
|
|
/**
|
|
* @license Angular v6.0.0-beta.2-8c5c0dac1
|
|
* (c) 2010-2018 Google, Inc. https://angular.io/
|
|
* License: MIT
|
|
*/
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Base for events the Router goes through, as opposed to events tied to a specific
|
|
* Route. `RouterEvent`s will only be fired one time for any given navigation.
|
|
*
|
|
* Example:
|
|
*
|
|
* ```
|
|
* class MyService {
|
|
* constructor(public router: Router, logger: Logger) {
|
|
* router.events.filter(e => e instanceof RouterEvent).subscribe(e => {
|
|
* logger.log(e.id, e.url);
|
|
* });
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var RouterEvent = /** @class */ (function () {
|
|
function RouterEvent(id, url) {
|
|
this.id = id;
|
|
this.url = url;
|
|
}
|
|
return RouterEvent;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents an event triggered when a navigation starts.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var NavigationStart = /** @class */ (function (_super) {
|
|
__extends(NavigationStart, _super);
|
|
function NavigationStart(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
navigationTrigger, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
restoredState) {
|
|
/** @docsNotRequired */
|
|
if (navigationTrigger === void 0) { navigationTrigger = 'imperative'; }
|
|
/** @docsNotRequired */
|
|
if (restoredState === void 0) { restoredState = null; }
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.navigationTrigger = navigationTrigger;
|
|
_this.restoredState = restoredState;
|
|
return _this;
|
|
}
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
NavigationStart.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () { return "NavigationStart(id: " + this.id + ", url: '" + this.url + "')"; };
|
|
return NavigationStart;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents an event triggered when a navigation ends successfully.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var NavigationEnd = /** @class */ (function (_super) {
|
|
__extends(NavigationEnd, _super);
|
|
function NavigationEnd(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, urlAfterRedirects) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.urlAfterRedirects = urlAfterRedirects;
|
|
return _this;
|
|
}
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
NavigationEnd.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "NavigationEnd(id: " + this.id + ", url: '" + this.url + "', urlAfterRedirects: '" + this.urlAfterRedirects + "')";
|
|
};
|
|
return NavigationEnd;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents an event triggered when a navigation is canceled.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var NavigationCancel = /** @class */ (function (_super) {
|
|
__extends(NavigationCancel, _super);
|
|
function NavigationCancel(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, reason) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.reason = reason;
|
|
return _this;
|
|
}
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
NavigationCancel.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () { return "NavigationCancel(id: " + this.id + ", url: '" + this.url + "')"; };
|
|
return NavigationCancel;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents an event triggered when a navigation fails due to an unexpected error.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var NavigationError = /** @class */ (function (_super) {
|
|
__extends(NavigationError, _super);
|
|
function NavigationError(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, error) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.error = error;
|
|
return _this;
|
|
}
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
NavigationError.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "NavigationError(id: " + this.id + ", url: '" + this.url + "', error: " + this.error + ")";
|
|
};
|
|
return NavigationError;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents an event triggered when routes are recognized.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RoutesRecognized = /** @class */ (function (_super) {
|
|
__extends(RoutesRecognized, _super);
|
|
function RoutesRecognized(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, urlAfterRedirects, state) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.urlAfterRedirects = urlAfterRedirects;
|
|
_this.state = state;
|
|
return _this;
|
|
}
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
RoutesRecognized.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "RoutesRecognized(id: " + this.id + ", url: '" + this.url + "', urlAfterRedirects: '" + this.urlAfterRedirects + "', state: " + this.state + ")";
|
|
};
|
|
return RoutesRecognized;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents the start of the Guard phase of routing.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var GuardsCheckStart = /** @class */ (function (_super) {
|
|
__extends(GuardsCheckStart, _super);
|
|
function GuardsCheckStart(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, urlAfterRedirects, state) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.urlAfterRedirects = urlAfterRedirects;
|
|
_this.state = state;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
GuardsCheckStart.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "GuardsCheckStart(id: " + this.id + ", url: '" + this.url + "', urlAfterRedirects: '" + this.urlAfterRedirects + "', state: " + this.state + ")";
|
|
};
|
|
return GuardsCheckStart;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents the end of the Guard phase of routing.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var GuardsCheckEnd = /** @class */ (function (_super) {
|
|
__extends(GuardsCheckEnd, _super);
|
|
function GuardsCheckEnd(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, urlAfterRedirects, state, shouldActivate) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.urlAfterRedirects = urlAfterRedirects;
|
|
_this.state = state;
|
|
_this.shouldActivate = shouldActivate;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
GuardsCheckEnd.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "GuardsCheckEnd(id: " + this.id + ", url: '" + this.url + "', urlAfterRedirects: '" + this.urlAfterRedirects + "', state: " + this.state + ", shouldActivate: " + this.shouldActivate + ")";
|
|
};
|
|
return GuardsCheckEnd;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents the start of the Resolve phase of routing. The timing of this
|
|
* event may change, thus it's experimental. In the current iteration it will run
|
|
* in the "resolve" phase whether there's things to resolve or not. In the future this
|
|
* behavior may change to only run when there are things to be resolved.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ResolveStart = /** @class */ (function (_super) {
|
|
__extends(ResolveStart, _super);
|
|
function ResolveStart(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, urlAfterRedirects, state) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.urlAfterRedirects = urlAfterRedirects;
|
|
_this.state = state;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ResolveStart.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "ResolveStart(id: " + this.id + ", url: '" + this.url + "', urlAfterRedirects: '" + this.urlAfterRedirects + "', state: " + this.state + ")";
|
|
};
|
|
return ResolveStart;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents the end of the Resolve phase of routing. See note on
|
|
* {\@link ResolveStart} for use of this experimental API.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ResolveEnd = /** @class */ (function (_super) {
|
|
__extends(ResolveEnd, _super);
|
|
function ResolveEnd(/** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
id, /** @docsNotRequired */
|
|
/** @docsNotRequired */
|
|
url, urlAfterRedirects, state) {
|
|
var _this = _super.call(this, id, url) || this;
|
|
_this.urlAfterRedirects = urlAfterRedirects;
|
|
_this.state = state;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ResolveEnd.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return "ResolveEnd(id: " + this.id + ", url: '" + this.url + "', urlAfterRedirects: '" + this.urlAfterRedirects + "', state: " + this.state + ")";
|
|
};
|
|
return ResolveEnd;
|
|
}(RouterEvent));
|
|
/**
|
|
* \@whatItDoes Represents an event triggered before lazy loading a route config.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var RouteConfigLoadStart = /** @class */ (function () {
|
|
function RouteConfigLoadStart(route) {
|
|
this.route = route;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouteConfigLoadStart.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return "RouteConfigLoadStart(path: " + this.route.path + ")"; };
|
|
return RouteConfigLoadStart;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents an event triggered when a route has been lazy loaded.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var RouteConfigLoadEnd = /** @class */ (function () {
|
|
function RouteConfigLoadEnd(route) {
|
|
this.route = route;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouteConfigLoadEnd.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return "RouteConfigLoadEnd(path: " + this.route.path + ")"; };
|
|
return RouteConfigLoadEnd;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents the start of end of the Resolve phase of routing. See note on
|
|
* {\@link ChildActivationEnd} for use of this experimental API.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ChildActivationStart = /** @class */ (function () {
|
|
function ChildActivationStart(snapshot) {
|
|
this.snapshot = snapshot;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ChildActivationStart.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
|
|
return "ChildActivationStart(path: '" + path + "')";
|
|
};
|
|
return ChildActivationStart;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents the start of end of the Resolve phase of routing. See note on
|
|
* {\@link ChildActivationStart} for use of this experimental API.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ChildActivationEnd = /** @class */ (function () {
|
|
function ChildActivationEnd(snapshot) {
|
|
this.snapshot = snapshot;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ChildActivationEnd.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
|
|
return "ChildActivationEnd(path: '" + path + "')";
|
|
};
|
|
return ChildActivationEnd;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents the start of end of the Resolve phase of routing. See note on
|
|
* {\@link ActivationEnd} for use of this experimental API.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ActivationStart = /** @class */ (function () {
|
|
function ActivationStart(snapshot) {
|
|
this.snapshot = snapshot;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ActivationStart.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
|
|
return "ActivationStart(path: '" + path + "')";
|
|
};
|
|
return ActivationStart;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents the start of end of the Resolve phase of routing. See note on
|
|
* {\@link ActivationStart} for use of this experimental API.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ActivationEnd = /** @class */ (function () {
|
|
function ActivationEnd(snapshot) {
|
|
this.snapshot = snapshot;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ActivationEnd.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || '';
|
|
return "ActivationEnd(path: '" + path + "')";
|
|
};
|
|
return ActivationEnd;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Name of the primary outlet.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var PRIMARY_OUTLET = 'primary';
|
|
/**
|
|
* Matrix and Query parameters.
|
|
*
|
|
* `ParamMap` makes it easier to work with parameters as they could have either a single value or
|
|
* multiple value. Because this should be known by the user, calling `get` or `getAll` returns the
|
|
* correct type (either `string` or `string[]`).
|
|
*
|
|
* The API is inspired by the URLSearchParams interface.
|
|
* see https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams
|
|
*
|
|
* \@stable
|
|
* @record
|
|
*/
|
|
|
|
var ParamsAsMap = /** @class */ (function () {
|
|
function ParamsAsMap(params) {
|
|
this.params = params || {};
|
|
}
|
|
/**
|
|
* @param {?} name
|
|
* @return {?}
|
|
*/
|
|
ParamsAsMap.prototype.has = /**
|
|
* @param {?} name
|
|
* @return {?}
|
|
*/
|
|
function (name) { return this.params.hasOwnProperty(name); };
|
|
/**
|
|
* @param {?} name
|
|
* @return {?}
|
|
*/
|
|
ParamsAsMap.prototype.get = /**
|
|
* @param {?} name
|
|
* @return {?}
|
|
*/
|
|
function (name) {
|
|
if (this.has(name)) {
|
|
var /** @type {?} */ v = this.params[name];
|
|
return Array.isArray(v) ? v[0] : v;
|
|
}
|
|
return null;
|
|
};
|
|
/**
|
|
* @param {?} name
|
|
* @return {?}
|
|
*/
|
|
ParamsAsMap.prototype.getAll = /**
|
|
* @param {?} name
|
|
* @return {?}
|
|
*/
|
|
function (name) {
|
|
if (this.has(name)) {
|
|
var /** @type {?} */ v = this.params[name];
|
|
return Array.isArray(v) ? v : [v];
|
|
}
|
|
return [];
|
|
};
|
|
Object.defineProperty(ParamsAsMap.prototype, "keys", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () { return Object.keys(this.params); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
return ParamsAsMap;
|
|
}());
|
|
/**
|
|
* Convert a {\@link Params} instance to a {\@link ParamMap}.
|
|
*
|
|
* \@stable
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function convertToParamMap(params) {
|
|
return new ParamsAsMap(params);
|
|
}
|
|
var NAVIGATION_CANCELING_ERROR = 'ngNavigationCancelingError';
|
|
/**
|
|
* @param {?} message
|
|
* @return {?}
|
|
*/
|
|
function navigationCancelingError(message) {
|
|
var /** @type {?} */ error = Error('NavigationCancelingError: ' + message);
|
|
(/** @type {?} */ (error))[NAVIGATION_CANCELING_ERROR] = true;
|
|
return error;
|
|
}
|
|
/**
|
|
* @param {?} error
|
|
* @return {?}
|
|
*/
|
|
function isNavigationCancelingError(error) {
|
|
return error && (/** @type {?} */ (error))[NAVIGATION_CANCELING_ERROR];
|
|
}
|
|
/**
|
|
* @param {?} segments
|
|
* @param {?} segmentGroup
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function defaultUrlMatcher(segments, segmentGroup, route) {
|
|
var /** @type {?} */ parts = /** @type {?} */ ((route.path)).split('/');
|
|
if (parts.length > segments.length) {
|
|
// The actual URL is shorter than the config, no match
|
|
return null;
|
|
}
|
|
if (route.pathMatch === 'full' &&
|
|
(segmentGroup.hasChildren() || parts.length < segments.length)) {
|
|
// The config is longer than the actual URL but we are looking for a full match, return null
|
|
return null;
|
|
}
|
|
var /** @type {?} */ posParams = {};
|
|
// Check each config part against the actual URL
|
|
for (var /** @type {?} */ index = 0; index < parts.length; index++) {
|
|
var /** @type {?} */ part = parts[index];
|
|
var /** @type {?} */ segment = segments[index];
|
|
var /** @type {?} */ isParameter = part.startsWith(':');
|
|
if (isParameter) {
|
|
posParams[part.substring(1)] = segment;
|
|
}
|
|
else if (part !== segment.path) {
|
|
// The actual URL part does not match the config, no match
|
|
return null;
|
|
}
|
|
}
|
|
return { consumed: segments.slice(0, parts.length), posParams: posParams };
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* See {\@link Routes} for more details.
|
|
* \@stable
|
|
* @record
|
|
*/
|
|
|
|
var LoadedRouterConfig = /** @class */ (function () {
|
|
function LoadedRouterConfig(routes, module) {
|
|
this.routes = routes;
|
|
this.module = module;
|
|
}
|
|
return LoadedRouterConfig;
|
|
}());
|
|
/**
|
|
* @param {?} config
|
|
* @param {?=} parentPath
|
|
* @return {?}
|
|
*/
|
|
function validateConfig(config, parentPath) {
|
|
if (parentPath === void 0) { parentPath = ''; }
|
|
// forEach doesn't iterate undefined values
|
|
for (var /** @type {?} */ i = 0; i < config.length; i++) {
|
|
var /** @type {?} */ route = config[i];
|
|
var /** @type {?} */ fullPath = getFullPath(parentPath, route);
|
|
validateNode(route, fullPath);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} fullPath
|
|
* @return {?}
|
|
*/
|
|
function validateNode(route, fullPath) {
|
|
if (!route) {
|
|
throw new Error("\n Invalid configuration of route '" + fullPath + "': Encountered undefined route.\n The reason might be an extra comma.\n\n Example:\n const routes: Routes = [\n { path: '', redirectTo: '/dashboard', pathMatch: 'full' },\n { path: 'dashboard', component: DashboardComponent },, << two commas\n { path: 'detail/:id', component: HeroDetailComponent }\n ];\n ");
|
|
}
|
|
if (Array.isArray(route)) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': Array cannot be specified");
|
|
}
|
|
if (!route.component && (route.outlet && route.outlet !== PRIMARY_OUTLET)) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': a componentless route cannot have a named outlet set");
|
|
}
|
|
if (route.redirectTo && route.children) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': redirectTo and children cannot be used together");
|
|
}
|
|
if (route.redirectTo && route.loadChildren) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': redirectTo and loadChildren cannot be used together");
|
|
}
|
|
if (route.children && route.loadChildren) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': children and loadChildren cannot be used together");
|
|
}
|
|
if (route.redirectTo && route.component) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': redirectTo and component cannot be used together");
|
|
}
|
|
if (route.path && route.matcher) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': path and matcher cannot be used together");
|
|
}
|
|
if (route.redirectTo === void 0 && !route.component && !route.children && !route.loadChildren) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "'. One of the following must be provided: component, redirectTo, children or loadChildren");
|
|
}
|
|
if (route.path === void 0 && route.matcher === void 0) {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': routes must have either a path or a matcher specified");
|
|
}
|
|
if (typeof route.path === 'string' && route.path.charAt(0) === '/') {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': path cannot start with a slash");
|
|
}
|
|
if (route.path === '' && route.redirectTo !== void 0 && route.pathMatch === void 0) {
|
|
var /** @type {?} */ exp = "The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.";
|
|
throw new Error("Invalid configuration of route '{path: \"" + fullPath + "\", redirectTo: \"" + route.redirectTo + "\"}': please provide 'pathMatch'. " + exp);
|
|
}
|
|
if (route.pathMatch !== void 0 && route.pathMatch !== 'full' && route.pathMatch !== 'prefix') {
|
|
throw new Error("Invalid configuration of route '" + fullPath + "': pathMatch can only be set to 'prefix' or 'full'");
|
|
}
|
|
if (route.children) {
|
|
validateConfig(route.children, fullPath);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} parentPath
|
|
* @param {?} currentRoute
|
|
* @return {?}
|
|
*/
|
|
function getFullPath(parentPath, currentRoute) {
|
|
if (!currentRoute) {
|
|
return parentPath;
|
|
}
|
|
if (!parentPath && !currentRoute.path) {
|
|
return '';
|
|
}
|
|
else if (parentPath && !currentRoute.path) {
|
|
return parentPath + "/";
|
|
}
|
|
else if (!parentPath && currentRoute.path) {
|
|
return currentRoute.path;
|
|
}
|
|
else {
|
|
return parentPath + "/" + currentRoute.path;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* @param {?} a
|
|
* @param {?} b
|
|
* @return {?}
|
|
*/
|
|
function shallowEqualArrays(a, b) {
|
|
if (a.length !== b.length)
|
|
return false;
|
|
for (var /** @type {?} */ i = 0; i < a.length; ++i) {
|
|
if (!shallowEqual(a[i], b[i]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* @param {?} a
|
|
* @param {?} b
|
|
* @return {?}
|
|
*/
|
|
function shallowEqual(a, b) {
|
|
var /** @type {?} */ k1 = Object.keys(a);
|
|
var /** @type {?} */ k2 = Object.keys(b);
|
|
if (k1.length != k2.length) {
|
|
return false;
|
|
}
|
|
var /** @type {?} */ key;
|
|
for (var /** @type {?} */ i = 0; i < k1.length; i++) {
|
|
key = k1[i];
|
|
if (a[key] !== b[key]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Flattens single-level nested arrays.
|
|
* @template T
|
|
* @param {?} arr
|
|
* @return {?}
|
|
*/
|
|
function flatten(arr) {
|
|
return Array.prototype.concat.apply([], arr);
|
|
}
|
|
/**
|
|
* Return the last element of an array.
|
|
* @template T
|
|
* @param {?} a
|
|
* @return {?}
|
|
*/
|
|
function last$1(a) {
|
|
return a.length > 0 ? a[a.length - 1] : null;
|
|
}
|
|
/**
|
|
* Verifys all booleans in an array are `true`.
|
|
* @param {?} bools
|
|
* @return {?}
|
|
*/
|
|
|
|
/**
|
|
* @template K, V
|
|
* @param {?} map
|
|
* @param {?} callback
|
|
* @return {?}
|
|
*/
|
|
function forEach(map$$1, callback) {
|
|
for (var /** @type {?} */ prop in map$$1) {
|
|
if (map$$1.hasOwnProperty(prop)) {
|
|
callback(map$$1[prop], prop);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @template A, B
|
|
* @param {?} obj
|
|
* @param {?} fn
|
|
* @return {?}
|
|
*/
|
|
function waitForMap(obj, fn) {
|
|
if (Object.keys(obj).length === 0) {
|
|
return rxjs_observable_of.of({});
|
|
}
|
|
var /** @type {?} */ waitHead = [];
|
|
var /** @type {?} */ waitTail = [];
|
|
var /** @type {?} */ res = {};
|
|
forEach(obj, function (a, k) {
|
|
var /** @type {?} */ mapped = rxjs_operator_map.map.call(fn(k, a), function (r) { return res[k] = r; });
|
|
if (k === PRIMARY_OUTLET) {
|
|
waitHead.push(mapped);
|
|
}
|
|
else {
|
|
waitTail.push(mapped);
|
|
}
|
|
});
|
|
var /** @type {?} */ concat$ = rxjs_operator_concatAll.concatAll.call(rxjs_observable_of.of.apply(void 0, waitHead.concat(waitTail)));
|
|
var /** @type {?} */ last$ = rxjs_operator_last.last.call(concat$);
|
|
return rxjs_operator_map.map.call(last$, function () { return res; });
|
|
}
|
|
/**
|
|
* ANDs Observables by merging all input observables, reducing to an Observable verifying all
|
|
* input Observables return `true`.
|
|
* @param {?} observables
|
|
* @return {?}
|
|
*/
|
|
function andObservables(observables) {
|
|
var /** @type {?} */ merged$ = rxjs_operator_mergeAll.mergeAll.call(observables);
|
|
return rxjs_operator_every.every.call(merged$, function (result) { return result === true; });
|
|
}
|
|
/**
|
|
* @template T
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
function wrapIntoObservable(value) {
|
|
if (_angular_core.ɵisObservable(value)) {
|
|
return value;
|
|
}
|
|
if (_angular_core.ɵisPromise(value)) {
|
|
// Use `Promise.resolve()` to wrap promise-like instances.
|
|
// Required ie when a Resolver returns a AngularJS `$q` promise to correctly trigger the
|
|
// change detection.
|
|
return rxjs_observable_fromPromise.fromPromise(Promise.resolve(value));
|
|
}
|
|
return rxjs_observable_of.of(/** @type {?} */ (value));
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
function createEmptyUrlTree() {
|
|
return new UrlTree(new UrlSegmentGroup([], {}), {}, null);
|
|
}
|
|
/**
|
|
* @param {?} container
|
|
* @param {?} containee
|
|
* @param {?} exact
|
|
* @return {?}
|
|
*/
|
|
function containsTree(container, containee, exact) {
|
|
if (exact) {
|
|
return equalQueryParams(container.queryParams, containee.queryParams) &&
|
|
equalSegmentGroups(container.root, containee.root);
|
|
}
|
|
return containsQueryParams(container.queryParams, containee.queryParams) &&
|
|
containsSegmentGroup(container.root, containee.root);
|
|
}
|
|
/**
|
|
* @param {?} container
|
|
* @param {?} containee
|
|
* @return {?}
|
|
*/
|
|
function equalQueryParams(container, containee) {
|
|
return shallowEqual(container, containee);
|
|
}
|
|
/**
|
|
* @param {?} container
|
|
* @param {?} containee
|
|
* @return {?}
|
|
*/
|
|
function equalSegmentGroups(container, containee) {
|
|
if (!equalPath(container.segments, containee.segments))
|
|
return false;
|
|
if (container.numberOfChildren !== containee.numberOfChildren)
|
|
return false;
|
|
for (var /** @type {?} */ c in containee.children) {
|
|
if (!container.children[c])
|
|
return false;
|
|
if (!equalSegmentGroups(container.children[c], containee.children[c]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* @param {?} container
|
|
* @param {?} containee
|
|
* @return {?}
|
|
*/
|
|
function containsQueryParams(container, containee) {
|
|
return Object.keys(containee).length <= Object.keys(container).length &&
|
|
Object.keys(containee).every(function (key) { return containee[key] === container[key]; });
|
|
}
|
|
/**
|
|
* @param {?} container
|
|
* @param {?} containee
|
|
* @return {?}
|
|
*/
|
|
function containsSegmentGroup(container, containee) {
|
|
return containsSegmentGroupHelper(container, containee, containee.segments);
|
|
}
|
|
/**
|
|
* @param {?} container
|
|
* @param {?} containee
|
|
* @param {?} containeePaths
|
|
* @return {?}
|
|
*/
|
|
function containsSegmentGroupHelper(container, containee, containeePaths) {
|
|
if (container.segments.length > containeePaths.length) {
|
|
var /** @type {?} */ current = container.segments.slice(0, containeePaths.length);
|
|
if (!equalPath(current, containeePaths))
|
|
return false;
|
|
if (containee.hasChildren())
|
|
return false;
|
|
return true;
|
|
}
|
|
else if (container.segments.length === containeePaths.length) {
|
|
if (!equalPath(container.segments, containeePaths))
|
|
return false;
|
|
for (var /** @type {?} */ c in containee.children) {
|
|
if (!container.children[c])
|
|
return false;
|
|
if (!containsSegmentGroup(container.children[c], containee.children[c]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
else {
|
|
var /** @type {?} */ current = containeePaths.slice(0, container.segments.length);
|
|
var /** @type {?} */ next = containeePaths.slice(container.segments.length);
|
|
if (!equalPath(container.segments, current))
|
|
return false;
|
|
if (!container.children[PRIMARY_OUTLET])
|
|
return false;
|
|
return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next);
|
|
}
|
|
}
|
|
/**
|
|
* \@whatItDoes Represents the parsed URL.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@Component({templateUrl:'template.html'})
|
|
* class MyComponent {
|
|
* constructor(router: Router) {
|
|
* const tree: UrlTree =
|
|
* router.parseUrl('/team/33/(user/victor//support:help)?debug=true#fragment');
|
|
* const f = tree.fragment; // return 'fragment'
|
|
* const q = tree.queryParams; // returns {debug: 'true'}
|
|
* const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];
|
|
* const s: UrlSegment[] = g.segments; // returns 2 segments 'team' and '33'
|
|
* g.children[PRIMARY_OUTLET].segments; // returns 2 segments 'user' and 'victor'
|
|
* g.children['support'].segments; // return 1 segment 'help'
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@description
|
|
*
|
|
* Since a router state is a tree, and the URL is nothing but a serialized state, the URL is a
|
|
* serialized tree.
|
|
* UrlTree is a data structure that provides a lot of affordances in dealing with URLs
|
|
*
|
|
* \@stable
|
|
*/
|
|
var UrlTree = /** @class */ (function () {
|
|
/** @internal */
|
|
function UrlTree(root, queryParams, fragment) {
|
|
this.root = root;
|
|
this.queryParams = queryParams;
|
|
this.fragment = fragment;
|
|
}
|
|
Object.defineProperty(UrlTree.prototype, "queryParamMap", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this._queryParamMap) {
|
|
this._queryParamMap = convertToParamMap(this.queryParams);
|
|
}
|
|
return this._queryParamMap;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
UrlTree.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () { return DEFAULT_SERIALIZER.serialize(this); };
|
|
return UrlTree;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents the parsed URL segment group.
|
|
*
|
|
* See {\@link UrlTree} for more information.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var UrlSegmentGroup = /** @class */ (function () {
|
|
function UrlSegmentGroup(segments, children) {
|
|
var _this = this;
|
|
this.segments = segments;
|
|
this.children = children;
|
|
/**
|
|
* The parent node in the url tree
|
|
*/
|
|
this.parent = null;
|
|
forEach(children, function (v, k) { return v.parent = _this; });
|
|
}
|
|
/** Whether the segment has child segments */
|
|
/**
|
|
* Whether the segment has child segments
|
|
* @return {?}
|
|
*/
|
|
UrlSegmentGroup.prototype.hasChildren = /**
|
|
* Whether the segment has child segments
|
|
* @return {?}
|
|
*/
|
|
function () { return this.numberOfChildren > 0; };
|
|
Object.defineProperty(UrlSegmentGroup.prototype, "numberOfChildren", {
|
|
/** Number of child segments */
|
|
get: /**
|
|
* Number of child segments
|
|
* @return {?}
|
|
*/
|
|
function () { return Object.keys(this.children).length; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
UrlSegmentGroup.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () { return serializePaths(this); };
|
|
return UrlSegmentGroup;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents a single URL segment.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@Component({templateUrl:'template.html'})
|
|
* class MyComponent {
|
|
* constructor(router: Router) {
|
|
* const tree: UrlTree = router.parseUrl('/team;id=33');
|
|
* const g: UrlSegmentGroup = tree.root.children[PRIMARY_OUTLET];
|
|
* const s: UrlSegment[] = g.segments;
|
|
* s[0].path; // returns 'team'
|
|
* s[0].parameters; // returns {id: 33}
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@description
|
|
*
|
|
* A UrlSegment is a part of a URL between the two slashes. It contains a path and the matrix
|
|
* parameters associated with the segment.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var UrlSegment = /** @class */ (function () {
|
|
function UrlSegment(path, parameters) {
|
|
this.path = path;
|
|
this.parameters = parameters;
|
|
}
|
|
Object.defineProperty(UrlSegment.prototype, "parameterMap", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this._parameterMap) {
|
|
this._parameterMap = convertToParamMap(this.parameters);
|
|
}
|
|
return this._parameterMap;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
UrlSegment.prototype.toString = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () { return serializePath(this); };
|
|
return UrlSegment;
|
|
}());
|
|
/**
|
|
* @param {?} as
|
|
* @param {?} bs
|
|
* @return {?}
|
|
*/
|
|
function equalSegments(as, bs) {
|
|
return equalPath(as, bs) && as.every(function (a, i) { return shallowEqual(a.parameters, bs[i].parameters); });
|
|
}
|
|
/**
|
|
* @param {?} as
|
|
* @param {?} bs
|
|
* @return {?}
|
|
*/
|
|
function equalPath(as, bs) {
|
|
if (as.length !== bs.length)
|
|
return false;
|
|
return as.every(function (a, i) { return a.path === bs[i].path; });
|
|
}
|
|
/**
|
|
* @template T
|
|
* @param {?} segment
|
|
* @param {?} fn
|
|
* @return {?}
|
|
*/
|
|
function mapChildrenIntoArray(segment, fn) {
|
|
var /** @type {?} */ res = [];
|
|
forEach(segment.children, function (child, childOutlet) {
|
|
if (childOutlet === PRIMARY_OUTLET) {
|
|
res = res.concat(fn(child, childOutlet));
|
|
}
|
|
});
|
|
forEach(segment.children, function (child, childOutlet) {
|
|
if (childOutlet !== PRIMARY_OUTLET) {
|
|
res = res.concat(fn(child, childOutlet));
|
|
}
|
|
});
|
|
return res;
|
|
}
|
|
/**
|
|
* \@whatItDoes Serializes and deserializes a URL string into a URL tree.
|
|
*
|
|
* \@description The url serialization strategy is customizable. You can
|
|
* make all URLs case insensitive by providing a custom UrlSerializer.
|
|
*
|
|
* See {\@link DefaultUrlSerializer} for an example of a URL serializer.
|
|
*
|
|
* \@stable
|
|
* @abstract
|
|
*/
|
|
var UrlSerializer = /** @class */ (function () {
|
|
function UrlSerializer() {
|
|
}
|
|
return UrlSerializer;
|
|
}());
|
|
/**
|
|
* \@whatItDoes A default implementation of the {\@link UrlSerializer}.
|
|
*
|
|
* \@description
|
|
*
|
|
* Example URLs:
|
|
*
|
|
* ```
|
|
* /inbox/33(popup:compose)
|
|
* /inbox/33;open=true/messages/44
|
|
* ```
|
|
*
|
|
* DefaultUrlSerializer uses parentheses to serialize secondary segments (e.g., popup:compose), the
|
|
* colon syntax to specify the outlet, and the ';parameter=value' syntax (e.g., open=true) to
|
|
* specify route specific parameters.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var DefaultUrlSerializer = /** @class */ (function () {
|
|
function DefaultUrlSerializer() {
|
|
}
|
|
/** Parses a url into a {@link UrlTree} */
|
|
/**
|
|
* Parses a url into a {\@link UrlTree}
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
DefaultUrlSerializer.prototype.parse = /**
|
|
* Parses a url into a {\@link UrlTree}
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
function (url) {
|
|
var /** @type {?} */ p = new UrlParser(url);
|
|
return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());
|
|
};
|
|
/** Converts a {@link UrlTree} into a url */
|
|
/**
|
|
* Converts a {\@link UrlTree} into a url
|
|
* @param {?} tree
|
|
* @return {?}
|
|
*/
|
|
DefaultUrlSerializer.prototype.serialize = /**
|
|
* Converts a {\@link UrlTree} into a url
|
|
* @param {?} tree
|
|
* @return {?}
|
|
*/
|
|
function (tree) {
|
|
var /** @type {?} */ segment = "/" + serializeSegment(tree.root, true);
|
|
var /** @type {?} */ query = serializeQueryParams(tree.queryParams);
|
|
var /** @type {?} */ fragment = typeof tree.fragment === "string" ? "#" + encodeURI((/** @type {?} */ ((tree.fragment)))) : '';
|
|
return "" + segment + query + fragment;
|
|
};
|
|
return DefaultUrlSerializer;
|
|
}());
|
|
var DEFAULT_SERIALIZER = new DefaultUrlSerializer();
|
|
/**
|
|
* @param {?} segment
|
|
* @return {?}
|
|
*/
|
|
function serializePaths(segment) {
|
|
return segment.segments.map(function (p) { return serializePath(p); }).join('/');
|
|
}
|
|
/**
|
|
* @param {?} segment
|
|
* @param {?} root
|
|
* @return {?}
|
|
*/
|
|
function serializeSegment(segment, root) {
|
|
if (!segment.hasChildren()) {
|
|
return serializePaths(segment);
|
|
}
|
|
if (root) {
|
|
var /** @type {?} */ primary = segment.children[PRIMARY_OUTLET] ?
|
|
serializeSegment(segment.children[PRIMARY_OUTLET], false) :
|
|
'';
|
|
var /** @type {?} */ children_1 = [];
|
|
forEach(segment.children, function (v, k) {
|
|
if (k !== PRIMARY_OUTLET) {
|
|
children_1.push(k + ":" + serializeSegment(v, false));
|
|
}
|
|
});
|
|
return children_1.length > 0 ? primary + "(" + children_1.join('//') + ")" : primary;
|
|
}
|
|
else {
|
|
var /** @type {?} */ children = mapChildrenIntoArray(segment, function (v, k) {
|
|
if (k === PRIMARY_OUTLET) {
|
|
return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];
|
|
}
|
|
return [k + ":" + serializeSegment(v, false)];
|
|
});
|
|
return serializePaths(segment) + "/(" + children.join('//') + ")";
|
|
}
|
|
}
|
|
/**
|
|
* This method is intended for encoding *key* or *value* parts of query component. We need a custom
|
|
* method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
|
|
* encoded per http://tools.ietf.org/html/rfc3986:
|
|
* query = *( pchar / "/" / "?" )
|
|
* pchar = unreserved / pct-encoded / sub-delims / ":" / "\@"
|
|
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
|
|
* pct-encoded = "%" HEXDIG HEXDIG
|
|
* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
|
|
* / "*" / "+" / "," / ";" / "="
|
|
* @param {?} s
|
|
* @return {?}
|
|
*/
|
|
function encode(s) {
|
|
return encodeURIComponent(s)
|
|
.replace(/%40/g, '@')
|
|
.replace(/%3A/gi, ':')
|
|
.replace(/%24/g, '$')
|
|
.replace(/%2C/gi, ',')
|
|
.replace(/%3B/gi, ';');
|
|
}
|
|
/**
|
|
* @param {?} s
|
|
* @return {?}
|
|
*/
|
|
function decode(s) {
|
|
return decodeURIComponent(s);
|
|
}
|
|
/**
|
|
* @param {?} path
|
|
* @return {?}
|
|
*/
|
|
function serializePath(path) {
|
|
return "" + encode(path.path) + serializeParams(path.parameters);
|
|
}
|
|
/**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function serializeParams(params) {
|
|
return Object.keys(params).map(function (key) { return ";" + encode(key) + "=" + encode(params[key]); }).join('');
|
|
}
|
|
/**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function serializeQueryParams(params) {
|
|
var /** @type {?} */ strParams = Object.keys(params).map(function (name) {
|
|
var /** @type {?} */ value = params[name];
|
|
return Array.isArray(value) ? value.map(function (v) { return encode(name) + "=" + encode(v); }).join('&') :
|
|
encode(name) + "=" + encode(value);
|
|
});
|
|
return strParams.length ? "?" + strParams.join("&") : '';
|
|
}
|
|
var SEGMENT_RE = /^[^\/()?;=&#]+/;
|
|
/**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
function matchSegments(str) {
|
|
var /** @type {?} */ match = str.match(SEGMENT_RE);
|
|
return match ? match[0] : '';
|
|
}
|
|
var QUERY_PARAM_RE = /^[^=?&#]+/;
|
|
/**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
function matchQueryParams(str) {
|
|
var /** @type {?} */ match = str.match(QUERY_PARAM_RE);
|
|
return match ? match[0] : '';
|
|
}
|
|
var QUERY_PARAM_VALUE_RE = /^[^?&#]+/;
|
|
/**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
function matchUrlQueryParamValue(str) {
|
|
var /** @type {?} */ match = str.match(QUERY_PARAM_VALUE_RE);
|
|
return match ? match[0] : '';
|
|
}
|
|
var UrlParser = /** @class */ (function () {
|
|
function UrlParser(url) {
|
|
this.url = url;
|
|
this.remaining = url;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseRootSegment = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.consumeOptional('/');
|
|
if (this.remaining === '' || this.peekStartsWith('?') || this.peekStartsWith('#')) {
|
|
return new UrlSegmentGroup([], {});
|
|
}
|
|
// The root segment group never has segments
|
|
return new UrlSegmentGroup([], this.parseChildren());
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseQueryParams = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ params = {};
|
|
if (this.consumeOptional('?')) {
|
|
do {
|
|
this.parseQueryParam(params);
|
|
} while (this.consumeOptional('&'));
|
|
}
|
|
return params;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseFragment = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.consumeOptional('#') ? decodeURI(this.remaining) : null;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseChildren = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (this.remaining === '') {
|
|
return {};
|
|
}
|
|
this.consumeOptional('/');
|
|
var /** @type {?} */ segments = [];
|
|
if (!this.peekStartsWith('(')) {
|
|
segments.push(this.parseSegment());
|
|
}
|
|
while (this.peekStartsWith('/') && !this.peekStartsWith('//') && !this.peekStartsWith('/(')) {
|
|
this.capture('/');
|
|
segments.push(this.parseSegment());
|
|
}
|
|
var /** @type {?} */ children = {};
|
|
if (this.peekStartsWith('/(')) {
|
|
this.capture('/');
|
|
children = this.parseParens(true);
|
|
}
|
|
var /** @type {?} */ res = {};
|
|
if (this.peekStartsWith('(')) {
|
|
res = this.parseParens(false);
|
|
}
|
|
if (segments.length > 0 || Object.keys(children).length > 0) {
|
|
res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);
|
|
}
|
|
return res;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseSegment = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ path = matchSegments(this.remaining);
|
|
if (path === '' && this.peekStartsWith(';')) {
|
|
throw new Error("Empty path url segment cannot have parameters: '" + this.remaining + "'.");
|
|
}
|
|
this.capture(path);
|
|
return new UrlSegment(decode(path), this.parseMatrixParams());
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseMatrixParams = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ params = {};
|
|
while (this.consumeOptional(';')) {
|
|
this.parseParam(params);
|
|
}
|
|
return params;
|
|
};
|
|
/**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseParam = /**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function (params) {
|
|
var /** @type {?} */ key = matchSegments(this.remaining);
|
|
if (!key) {
|
|
return;
|
|
}
|
|
this.capture(key);
|
|
var /** @type {?} */ value = '';
|
|
if (this.consumeOptional('=')) {
|
|
var /** @type {?} */ valueMatch = matchSegments(this.remaining);
|
|
if (valueMatch) {
|
|
value = valueMatch;
|
|
this.capture(value);
|
|
}
|
|
}
|
|
params[decode(key)] = decode(value);
|
|
};
|
|
/**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseQueryParam = /**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function (params) {
|
|
var /** @type {?} */ key = matchQueryParams(this.remaining);
|
|
if (!key) {
|
|
return;
|
|
}
|
|
this.capture(key);
|
|
var /** @type {?} */ value = '';
|
|
if (this.consumeOptional('=')) {
|
|
var /** @type {?} */ valueMatch = matchUrlQueryParamValue(this.remaining);
|
|
if (valueMatch) {
|
|
value = valueMatch;
|
|
this.capture(value);
|
|
}
|
|
}
|
|
var /** @type {?} */ decodedKey = decode(key);
|
|
var /** @type {?} */ decodedVal = decode(value);
|
|
if (params.hasOwnProperty(decodedKey)) {
|
|
// Append to existing values
|
|
var /** @type {?} */ currentVal = params[decodedKey];
|
|
if (!Array.isArray(currentVal)) {
|
|
currentVal = [currentVal];
|
|
params[decodedKey] = currentVal;
|
|
}
|
|
currentVal.push(decodedVal);
|
|
}
|
|
else {
|
|
// Create a new value
|
|
params[decodedKey] = decodedVal;
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} allowPrimary
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.parseParens = /**
|
|
* @param {?} allowPrimary
|
|
* @return {?}
|
|
*/
|
|
function (allowPrimary) {
|
|
var /** @type {?} */ segments = {};
|
|
this.capture('(');
|
|
while (!this.consumeOptional(')') && this.remaining.length > 0) {
|
|
var /** @type {?} */ path = matchSegments(this.remaining);
|
|
var /** @type {?} */ next = this.remaining[path.length];
|
|
// if is is not one of these characters, then the segment was unescaped
|
|
// or the group was not closed
|
|
if (next !== '/' && next !== ')' && next !== ';') {
|
|
throw new Error("Cannot parse url '" + this.url + "'");
|
|
}
|
|
var /** @type {?} */ outletName = /** @type {?} */ ((undefined));
|
|
if (path.indexOf(':') > -1) {
|
|
outletName = path.substr(0, path.indexOf(':'));
|
|
this.capture(outletName);
|
|
this.capture(':');
|
|
}
|
|
else if (allowPrimary) {
|
|
outletName = PRIMARY_OUTLET;
|
|
}
|
|
var /** @type {?} */ children = this.parseChildren();
|
|
segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] :
|
|
new UrlSegmentGroup([], children);
|
|
this.consumeOptional('//');
|
|
}
|
|
return segments;
|
|
};
|
|
/**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.peekStartsWith = /**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
function (str) { return this.remaining.startsWith(str); };
|
|
/**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.consumeOptional = /**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
function (str) {
|
|
if (this.peekStartsWith(str)) {
|
|
this.remaining = this.remaining.substring(str.length);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
/**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
UrlParser.prototype.capture = /**
|
|
* @param {?} str
|
|
* @return {?}
|
|
*/
|
|
function (str) {
|
|
if (!this.consumeOptional(str)) {
|
|
throw new Error("Expected \"" + str + "\".");
|
|
}
|
|
};
|
|
return UrlParser;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
var NoMatch = /** @class */ (function () {
|
|
function NoMatch(segmentGroup) {
|
|
this.segmentGroup = segmentGroup || null;
|
|
}
|
|
return NoMatch;
|
|
}());
|
|
var AbsoluteRedirect = /** @class */ (function () {
|
|
function AbsoluteRedirect(urlTree) {
|
|
this.urlTree = urlTree;
|
|
}
|
|
return AbsoluteRedirect;
|
|
}());
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
function noMatch(segmentGroup) {
|
|
return new rxjs_Observable.Observable(function (obs) { return obs.error(new NoMatch(segmentGroup)); });
|
|
}
|
|
/**
|
|
* @param {?} newTree
|
|
* @return {?}
|
|
*/
|
|
function absoluteRedirect(newTree) {
|
|
return new rxjs_Observable.Observable(function (obs) { return obs.error(new AbsoluteRedirect(newTree)); });
|
|
}
|
|
/**
|
|
* @param {?} redirectTo
|
|
* @return {?}
|
|
*/
|
|
function namedOutletsRedirect(redirectTo) {
|
|
return new rxjs_Observable.Observable(function (obs) {
|
|
return obs.error(new Error("Only absolute redirects can have named outlets. redirectTo: '" + redirectTo + "'"));
|
|
});
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function canLoadFails(route) {
|
|
return new rxjs_Observable.Observable(function (obs) {
|
|
return obs.error(navigationCancelingError("Cannot load children because the guard of the route \"path: '" + route.path + "'\" returned false"));
|
|
});
|
|
}
|
|
/**
|
|
* Returns the `UrlTree` with the redirection applied.
|
|
*
|
|
* Lazy modules are loaded along the way.
|
|
* @param {?} moduleInjector
|
|
* @param {?} configLoader
|
|
* @param {?} urlSerializer
|
|
* @param {?} urlTree
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
function applyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config) {
|
|
return new ApplyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config).apply();
|
|
}
|
|
var ApplyRedirects = /** @class */ (function () {
|
|
function ApplyRedirects(moduleInjector, configLoader, urlSerializer, urlTree, config) {
|
|
this.configLoader = configLoader;
|
|
this.urlSerializer = urlSerializer;
|
|
this.urlTree = urlTree;
|
|
this.config = config;
|
|
this.allowRedirects = true;
|
|
this.ngModule = moduleInjector.get(_angular_core.NgModuleRef);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.apply = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
var /** @type {?} */ expanded$ = this.expandSegmentGroup(this.ngModule, this.config, this.urlTree.root, PRIMARY_OUTLET);
|
|
var /** @type {?} */ urlTrees$ = rxjs_operator_map.map.call(expanded$, function (rootSegmentGroup) {
|
|
return _this.createUrlTree(rootSegmentGroup, _this.urlTree.queryParams, /** @type {?} */ ((_this.urlTree.fragment)));
|
|
});
|
|
return rxjs_operator_catch._catch.call(urlTrees$, function (e) {
|
|
if (e instanceof AbsoluteRedirect) {
|
|
// after an absolute redirect we do not apply any more redirects!
|
|
// after an absolute redirect we do not apply any more redirects!
|
|
_this.allowRedirects = false;
|
|
// we need to run matching, so we can fetch all lazy-loaded modules
|
|
return _this.match(e.urlTree);
|
|
}
|
|
if (e instanceof NoMatch) {
|
|
throw _this.noMatchError(e);
|
|
}
|
|
throw e;
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} tree
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.match = /**
|
|
* @param {?} tree
|
|
* @return {?}
|
|
*/
|
|
function (tree) {
|
|
var _this = this;
|
|
var /** @type {?} */ expanded$ = this.expandSegmentGroup(this.ngModule, this.config, tree.root, PRIMARY_OUTLET);
|
|
var /** @type {?} */ mapped$ = rxjs_operator_map.map.call(expanded$, function (rootSegmentGroup) {
|
|
return _this.createUrlTree(rootSegmentGroup, tree.queryParams, /** @type {?} */ ((tree.fragment)));
|
|
});
|
|
return rxjs_operator_catch._catch.call(mapped$, function (e) {
|
|
if (e instanceof NoMatch) {
|
|
throw _this.noMatchError(e);
|
|
}
|
|
throw e;
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} e
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.noMatchError = /**
|
|
* @param {?} e
|
|
* @return {?}
|
|
*/
|
|
function (e) {
|
|
return new Error("Cannot match any routes. URL Segment: '" + e.segmentGroup + "'");
|
|
};
|
|
/**
|
|
* @param {?} rootCandidate
|
|
* @param {?} queryParams
|
|
* @param {?} fragment
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.createUrlTree = /**
|
|
* @param {?} rootCandidate
|
|
* @param {?} queryParams
|
|
* @param {?} fragment
|
|
* @return {?}
|
|
*/
|
|
function (rootCandidate, queryParams, fragment) {
|
|
var /** @type {?} */ root = rootCandidate.segments.length > 0 ?
|
|
new UrlSegmentGroup([], (_a = {}, _a[PRIMARY_OUTLET] = rootCandidate, _a)) :
|
|
rootCandidate;
|
|
return new UrlTree(root, queryParams, fragment);
|
|
var _a;
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @param {?} segmentGroup
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandSegmentGroup = /**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @param {?} segmentGroup
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, routes, segmentGroup, outlet) {
|
|
if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
|
|
return rxjs_operator_map.map.call(this.expandChildren(ngModule, routes, segmentGroup), function (children) { return new UrlSegmentGroup([], children); });
|
|
}
|
|
return this.expandSegment(ngModule, segmentGroup, routes, segmentGroup.segments, outlet, true);
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandChildren = /**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, routes, segmentGroup) {
|
|
var _this = this;
|
|
return waitForMap(segmentGroup.children, function (childOutlet, child) { return _this.expandSegmentGroup(ngModule, routes, child, childOutlet); });
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @param {?} allowRedirects
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandSegment = /**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @param {?} allowRedirects
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, segmentGroup, routes, segments, outlet, allowRedirects) {
|
|
var _this = this;
|
|
var /** @type {?} */ routes$ = rxjs_observable_of.of.apply(void 0, routes);
|
|
var /** @type {?} */ processedRoutes$ = rxjs_operator_map.map.call(routes$, function (r) {
|
|
var /** @type {?} */ expanded$ = _this.expandSegmentAgainstRoute(ngModule, segmentGroup, routes, r, segments, outlet, allowRedirects);
|
|
return rxjs_operator_catch._catch.call(expanded$, function (e) {
|
|
if (e instanceof NoMatch) {
|
|
return rxjs_observable_of.of(null);
|
|
}
|
|
throw e;
|
|
});
|
|
});
|
|
var /** @type {?} */ concattedProcessedRoutes$ = rxjs_operator_concatAll.concatAll.call(processedRoutes$);
|
|
var /** @type {?} */ first$ = rxjs_operator_first.first.call(concattedProcessedRoutes$, function (s) { return !!s; });
|
|
return rxjs_operator_catch._catch.call(first$, function (e, _) {
|
|
if (e instanceof rxjs_util_EmptyError.EmptyError || e.name === 'EmptyError') {
|
|
if (_this.noLeftoversInUrl(segmentGroup, segments, outlet)) {
|
|
return rxjs_observable_of.of(new UrlSegmentGroup([], {}));
|
|
}
|
|
throw new NoMatch(segmentGroup);
|
|
}
|
|
throw e;
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.noLeftoversInUrl = /**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (segmentGroup, segments, outlet) {
|
|
return segments.length === 0 && !segmentGroup.children[outlet];
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} paths
|
|
* @param {?} outlet
|
|
* @param {?} allowRedirects
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandSegmentAgainstRoute = /**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} paths
|
|
* @param {?} outlet
|
|
* @param {?} allowRedirects
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, segmentGroup, routes, route, paths, outlet, allowRedirects) {
|
|
if (getOutlet(route) !== outlet) {
|
|
return noMatch(segmentGroup);
|
|
}
|
|
if (route.redirectTo === undefined) {
|
|
return this.matchSegmentAgainstRoute(ngModule, segmentGroup, route, paths);
|
|
}
|
|
if (allowRedirects && this.allowRedirects) {
|
|
return this.expandSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, paths, outlet);
|
|
}
|
|
return noMatch(segmentGroup);
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandSegmentAgainstRouteUsingRedirect = /**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, segmentGroup, routes, route, segments, outlet) {
|
|
if (route.path === '**') {
|
|
return this.expandWildCardWithParamsAgainstRouteUsingRedirect(ngModule, routes, route, outlet);
|
|
}
|
|
return this.expandRegularSegmentAgainstRouteUsingRedirect(ngModule, segmentGroup, routes, route, segments, outlet);
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandWildCardWithParamsAgainstRouteUsingRedirect = /**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, routes, route, outlet) {
|
|
var _this = this;
|
|
var /** @type {?} */ newTree = this.applyRedirectCommands([], /** @type {?} */ ((route.redirectTo)), {});
|
|
if (/** @type {?} */ ((route.redirectTo)).startsWith('/')) {
|
|
return absoluteRedirect(newTree);
|
|
}
|
|
return rxjs_operator_mergeMap.mergeMap.call(this.lineralizeSegments(route, newTree), function (newSegments) {
|
|
var /** @type {?} */ group = new UrlSegmentGroup(newSegments, {});
|
|
return _this.expandSegment(ngModule, group, routes, newSegments, outlet, false);
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.expandRegularSegmentAgainstRouteUsingRedirect = /**
|
|
* @param {?} ngModule
|
|
* @param {?} segmentGroup
|
|
* @param {?} routes
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, segmentGroup, routes, route, segments, outlet) {
|
|
var _this = this;
|
|
var _a = match(segmentGroup, route, segments), matched = _a.matched, consumedSegments = _a.consumedSegments, lastChild = _a.lastChild, positionalParamSegments = _a.positionalParamSegments;
|
|
if (!matched)
|
|
return noMatch(segmentGroup);
|
|
var /** @type {?} */ newTree = this.applyRedirectCommands(consumedSegments, /** @type {?} */ ((route.redirectTo)), /** @type {?} */ (positionalParamSegments));
|
|
if (/** @type {?} */ ((route.redirectTo)).startsWith('/')) {
|
|
return absoluteRedirect(newTree);
|
|
}
|
|
return rxjs_operator_mergeMap.mergeMap.call(this.lineralizeSegments(route, newTree), function (newSegments) {
|
|
return _this.expandSegment(ngModule, segmentGroup, routes, newSegments.concat(segments.slice(lastChild)), outlet, false);
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} rawSegmentGroup
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.matchSegmentAgainstRoute = /**
|
|
* @param {?} ngModule
|
|
* @param {?} rawSegmentGroup
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, rawSegmentGroup, route, segments) {
|
|
var _this = this;
|
|
if (route.path === '**') {
|
|
if (route.loadChildren) {
|
|
return rxjs_operator_map.map.call(this.configLoader.load(ngModule.injector, route), function (cfg) {
|
|
route._loadedConfig = cfg;
|
|
return new UrlSegmentGroup(segments, {});
|
|
});
|
|
}
|
|
return rxjs_observable_of.of(new UrlSegmentGroup(segments, {}));
|
|
}
|
|
var _a = match(rawSegmentGroup, route, segments), matched = _a.matched, consumedSegments = _a.consumedSegments, lastChild = _a.lastChild;
|
|
if (!matched)
|
|
return noMatch(rawSegmentGroup);
|
|
var /** @type {?} */ rawSlicedSegments = segments.slice(lastChild);
|
|
var /** @type {?} */ childConfig$ = this.getChildConfig(ngModule, route);
|
|
return rxjs_operator_mergeMap.mergeMap.call(childConfig$, function (routerConfig) {
|
|
var /** @type {?} */ childModule = routerConfig.module;
|
|
var /** @type {?} */ childConfig = routerConfig.routes;
|
|
var _a = split(rawSegmentGroup, consumedSegments, rawSlicedSegments, childConfig), segmentGroup = _a.segmentGroup, slicedSegments = _a.slicedSegments;
|
|
if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
|
|
var /** @type {?} */ expanded$_1 = _this.expandChildren(childModule, childConfig, segmentGroup);
|
|
return rxjs_operator_map.map.call(expanded$_1, function (children) { return new UrlSegmentGroup(consumedSegments, children); });
|
|
}
|
|
if (childConfig.length === 0 && slicedSegments.length === 0) {
|
|
return rxjs_observable_of.of(new UrlSegmentGroup(consumedSegments, {}));
|
|
}
|
|
var /** @type {?} */ expanded$ = _this.expandSegment(childModule, segmentGroup, childConfig, slicedSegments, PRIMARY_OUTLET, true);
|
|
return rxjs_operator_map.map.call(expanded$, function (cs) {
|
|
return new UrlSegmentGroup(consumedSegments.concat(cs.segments), cs.children);
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.getChildConfig = /**
|
|
* @param {?} ngModule
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, route) {
|
|
var _this = this;
|
|
if (route.children) {
|
|
// The children belong to the same module
|
|
return rxjs_observable_of.of(new LoadedRouterConfig(route.children, ngModule));
|
|
}
|
|
if (route.loadChildren) {
|
|
// lazy children belong to the loaded module
|
|
if (route._loadedConfig !== undefined) {
|
|
return rxjs_observable_of.of(route._loadedConfig);
|
|
}
|
|
return rxjs_operator_mergeMap.mergeMap.call(runCanLoadGuard(ngModule.injector, route), function (shouldLoad) {
|
|
if (shouldLoad) {
|
|
return rxjs_operator_map.map.call(_this.configLoader.load(ngModule.injector, route), function (cfg) {
|
|
route._loadedConfig = cfg;
|
|
return cfg;
|
|
});
|
|
}
|
|
return canLoadFails(route);
|
|
});
|
|
}
|
|
return rxjs_observable_of.of(new LoadedRouterConfig([], ngModule));
|
|
};
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} urlTree
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.lineralizeSegments = /**
|
|
* @param {?} route
|
|
* @param {?} urlTree
|
|
* @return {?}
|
|
*/
|
|
function (route, urlTree) {
|
|
var /** @type {?} */ res = [];
|
|
var /** @type {?} */ c = urlTree.root;
|
|
while (true) {
|
|
res = res.concat(c.segments);
|
|
if (c.numberOfChildren === 0) {
|
|
return rxjs_observable_of.of(res);
|
|
}
|
|
if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {
|
|
return namedOutletsRedirect(/** @type {?} */ ((route.redirectTo)));
|
|
}
|
|
c = c.children[PRIMARY_OUTLET];
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} segments
|
|
* @param {?} redirectTo
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.applyRedirectCommands = /**
|
|
* @param {?} segments
|
|
* @param {?} redirectTo
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
function (segments, redirectTo, posParams) {
|
|
return this.applyRedirectCreatreUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
|
|
};
|
|
/**
|
|
* @param {?} redirectTo
|
|
* @param {?} urlTree
|
|
* @param {?} segments
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.applyRedirectCreatreUrlTree = /**
|
|
* @param {?} redirectTo
|
|
* @param {?} urlTree
|
|
* @param {?} segments
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
function (redirectTo, urlTree, segments, posParams) {
|
|
var /** @type {?} */ newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
|
|
return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
|
|
};
|
|
/**
|
|
* @param {?} redirectToParams
|
|
* @param {?} actualParams
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.createQueryParams = /**
|
|
* @param {?} redirectToParams
|
|
* @param {?} actualParams
|
|
* @return {?}
|
|
*/
|
|
function (redirectToParams, actualParams) {
|
|
var /** @type {?} */ res = {};
|
|
forEach(redirectToParams, function (v, k) {
|
|
var /** @type {?} */ copySourceValue = typeof v === 'string' && v.startsWith(':');
|
|
if (copySourceValue) {
|
|
var /** @type {?} */ sourceName = v.substring(1);
|
|
res[k] = actualParams[sourceName];
|
|
}
|
|
else {
|
|
res[k] = v;
|
|
}
|
|
});
|
|
return res;
|
|
};
|
|
/**
|
|
* @param {?} redirectTo
|
|
* @param {?} group
|
|
* @param {?} segments
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.createSegmentGroup = /**
|
|
* @param {?} redirectTo
|
|
* @param {?} group
|
|
* @param {?} segments
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
function (redirectTo, group, segments, posParams) {
|
|
var _this = this;
|
|
var /** @type {?} */ updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
|
|
var /** @type {?} */ children = {};
|
|
forEach(group.children, function (child, name) {
|
|
children[name] = _this.createSegmentGroup(redirectTo, child, segments, posParams);
|
|
});
|
|
return new UrlSegmentGroup(updatedSegments, children);
|
|
};
|
|
/**
|
|
* @param {?} redirectTo
|
|
* @param {?} redirectToSegments
|
|
* @param {?} actualSegments
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.createSegments = /**
|
|
* @param {?} redirectTo
|
|
* @param {?} redirectToSegments
|
|
* @param {?} actualSegments
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
function (redirectTo, redirectToSegments, actualSegments, posParams) {
|
|
var _this = this;
|
|
return redirectToSegments.map(function (s) {
|
|
return s.path.startsWith(':') ? _this.findPosParam(redirectTo, s, posParams) :
|
|
_this.findOrReturn(s, actualSegments);
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} redirectTo
|
|
* @param {?} redirectToUrlSegment
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.findPosParam = /**
|
|
* @param {?} redirectTo
|
|
* @param {?} redirectToUrlSegment
|
|
* @param {?} posParams
|
|
* @return {?}
|
|
*/
|
|
function (redirectTo, redirectToUrlSegment, posParams) {
|
|
var /** @type {?} */ pos = posParams[redirectToUrlSegment.path.substring(1)];
|
|
if (!pos)
|
|
throw new Error("Cannot redirect to '" + redirectTo + "'. Cannot find '" + redirectToUrlSegment.path + "'.");
|
|
return pos;
|
|
};
|
|
/**
|
|
* @param {?} redirectToUrlSegment
|
|
* @param {?} actualSegments
|
|
* @return {?}
|
|
*/
|
|
ApplyRedirects.prototype.findOrReturn = /**
|
|
* @param {?} redirectToUrlSegment
|
|
* @param {?} actualSegments
|
|
* @return {?}
|
|
*/
|
|
function (redirectToUrlSegment, actualSegments) {
|
|
var /** @type {?} */ idx = 0;
|
|
for (var _i = 0, actualSegments_1 = actualSegments; _i < actualSegments_1.length; _i++) {
|
|
var s = actualSegments_1[_i];
|
|
if (s.path === redirectToUrlSegment.path) {
|
|
actualSegments.splice(idx);
|
|
return s;
|
|
}
|
|
idx++;
|
|
}
|
|
return redirectToUrlSegment;
|
|
};
|
|
return ApplyRedirects;
|
|
}());
|
|
/**
|
|
* @param {?} moduleInjector
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function runCanLoadGuard(moduleInjector, route) {
|
|
var /** @type {?} */ canLoad = route.canLoad;
|
|
if (!canLoad || canLoad.length === 0)
|
|
return rxjs_observable_of.of(true);
|
|
var /** @type {?} */ obs = rxjs_operator_map.map.call(rxjs_observable_from.from(canLoad), function (injectionToken) {
|
|
var /** @type {?} */ guard = moduleInjector.get(injectionToken);
|
|
return wrapIntoObservable(guard.canLoad ? guard.canLoad(route) : guard(route));
|
|
});
|
|
return andObservables(obs);
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @return {?}
|
|
*/
|
|
function match(segmentGroup, route, segments) {
|
|
if (route.path === '') {
|
|
if ((route.pathMatch === 'full') && (segmentGroup.hasChildren() || segments.length > 0)) {
|
|
return { matched: false, consumedSegments: [], lastChild: 0, positionalParamSegments: {} };
|
|
}
|
|
return { matched: true, consumedSegments: [], lastChild: 0, positionalParamSegments: {} };
|
|
}
|
|
var /** @type {?} */ matcher = route.matcher || defaultUrlMatcher;
|
|
var /** @type {?} */ res = matcher(segments, segmentGroup, route);
|
|
if (!res) {
|
|
return {
|
|
matched: false,
|
|
consumedSegments: /** @type {?} */ ([]),
|
|
lastChild: 0,
|
|
positionalParamSegments: {},
|
|
};
|
|
}
|
|
return {
|
|
matched: true,
|
|
consumedSegments: /** @type {?} */ ((res.consumed)),
|
|
lastChild: /** @type {?} */ ((res.consumed.length)),
|
|
positionalParamSegments: /** @type {?} */ ((res.posParams)),
|
|
};
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} consumedSegments
|
|
* @param {?} slicedSegments
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
function split(segmentGroup, consumedSegments, slicedSegments, config) {
|
|
if (slicedSegments.length > 0 &&
|
|
containsEmptyPathRedirectsWithNamedOutlets(segmentGroup, slicedSegments, config)) {
|
|
var /** @type {?} */ s = new UrlSegmentGroup(consumedSegments, createChildrenForEmptySegments(config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
|
|
return { segmentGroup: mergeTrivialChildren(s), slicedSegments: [] };
|
|
}
|
|
if (slicedSegments.length === 0 &&
|
|
containsEmptyPathRedirects(segmentGroup, slicedSegments, config)) {
|
|
var /** @type {?} */ s = new UrlSegmentGroup(segmentGroup.segments, addEmptySegmentsToChildrenIfNeeded(segmentGroup, slicedSegments, config, segmentGroup.children));
|
|
return { segmentGroup: mergeTrivialChildren(s), slicedSegments: slicedSegments };
|
|
}
|
|
return { segmentGroup: segmentGroup, slicedSegments: slicedSegments };
|
|
}
|
|
/**
|
|
* @param {?} s
|
|
* @return {?}
|
|
*/
|
|
function mergeTrivialChildren(s) {
|
|
if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {
|
|
var /** @type {?} */ c = s.children[PRIMARY_OUTLET];
|
|
return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);
|
|
}
|
|
return s;
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} slicedSegments
|
|
* @param {?} routes
|
|
* @param {?} children
|
|
* @return {?}
|
|
*/
|
|
function addEmptySegmentsToChildrenIfNeeded(segmentGroup, slicedSegments, routes, children) {
|
|
var /** @type {?} */ res = {};
|
|
for (var _i = 0, routes_1 = routes; _i < routes_1.length; _i++) {
|
|
var r = routes_1[_i];
|
|
if (isEmptyPathRedirect(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
|
|
res[getOutlet(r)] = new UrlSegmentGroup([], {});
|
|
}
|
|
}
|
|
return __assign({}, children, res);
|
|
}
|
|
/**
|
|
* @param {?} routes
|
|
* @param {?} primarySegmentGroup
|
|
* @return {?}
|
|
*/
|
|
function createChildrenForEmptySegments(routes, primarySegmentGroup) {
|
|
var /** @type {?} */ res = {};
|
|
res[PRIMARY_OUTLET] = primarySegmentGroup;
|
|
for (var _i = 0, routes_2 = routes; _i < routes_2.length; _i++) {
|
|
var r = routes_2[_i];
|
|
if (r.path === '' && getOutlet(r) !== PRIMARY_OUTLET) {
|
|
res[getOutlet(r)] = new UrlSegmentGroup([], {});
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function containsEmptyPathRedirectsWithNamedOutlets(segmentGroup, segments, routes) {
|
|
return routes.some(function (r) { return isEmptyPathRedirect(segmentGroup, segments, r) && getOutlet(r) !== PRIMARY_OUTLET; });
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function containsEmptyPathRedirects(segmentGroup, segments, routes) {
|
|
return routes.some(function (r) { return isEmptyPathRedirect(segmentGroup, segments, r); });
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} r
|
|
* @return {?}
|
|
*/
|
|
function isEmptyPathRedirect(segmentGroup, segments, r) {
|
|
if ((segmentGroup.hasChildren() || segments.length > 0) && r.pathMatch === 'full') {
|
|
return false;
|
|
}
|
|
return r.path === '' && r.redirectTo !== undefined;
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function getOutlet(route) {
|
|
return route.outlet || PRIMARY_OUTLET;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
var Tree = /** @class */ (function () {
|
|
function Tree(root) {
|
|
this._root = root;
|
|
}
|
|
Object.defineProperty(Tree.prototype, "root", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () { return this._root.value; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @internal
|
|
*/
|
|
/**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
Tree.prototype.parent = /**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
function (t) {
|
|
var /** @type {?} */ p = this.pathFromRoot(t);
|
|
return p.length > 1 ? p[p.length - 2] : null;
|
|
};
|
|
/**
|
|
* @internal
|
|
*/
|
|
/**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
Tree.prototype.children = /**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
function (t) {
|
|
var /** @type {?} */ n = findNode(t, this._root);
|
|
return n ? n.children.map(function (t) { return t.value; }) : [];
|
|
};
|
|
/**
|
|
* @internal
|
|
*/
|
|
/**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
Tree.prototype.firstChild = /**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
function (t) {
|
|
var /** @type {?} */ n = findNode(t, this._root);
|
|
return n && n.children.length > 0 ? n.children[0].value : null;
|
|
};
|
|
/**
|
|
* @internal
|
|
*/
|
|
/**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
Tree.prototype.siblings = /**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
function (t) {
|
|
var /** @type {?} */ p = findPath(t, this._root);
|
|
if (p.length < 2)
|
|
return [];
|
|
var /** @type {?} */ c = p[p.length - 2].children.map(function (c) { return c.value; });
|
|
return c.filter(function (cc) { return cc !== t; });
|
|
};
|
|
/**
|
|
* @internal
|
|
*/
|
|
/**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
Tree.prototype.pathFromRoot = /**
|
|
* \@internal
|
|
* @param {?} t
|
|
* @return {?}
|
|
*/
|
|
function (t) { return findPath(t, this._root).map(function (s) { return s.value; }); };
|
|
return Tree;
|
|
}());
|
|
/**
|
|
* @template T
|
|
* @param {?} value
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
function findNode(value, node) {
|
|
if (value === node.value)
|
|
return node;
|
|
for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
|
|
var child = _a[_i];
|
|
var /** @type {?} */ node_1 = findNode(value, child);
|
|
if (node_1)
|
|
return node_1;
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* @template T
|
|
* @param {?} value
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
function findPath(value, node) {
|
|
if (value === node.value)
|
|
return [node];
|
|
for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
|
|
var child = _a[_i];
|
|
var /** @type {?} */ path = findPath(value, child);
|
|
if (path.length) {
|
|
path.unshift(node);
|
|
return path;
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
var TreeNode = /** @class */ (function () {
|
|
function TreeNode(value, children) {
|
|
this.value = value;
|
|
this.children = children;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
TreeNode.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return "TreeNode(" + this.value + ")"; };
|
|
return TreeNode;
|
|
}());
|
|
/**
|
|
* @template T
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
function nodeChildrenAsMap(node) {
|
|
var /** @type {?} */ map$$1 = {};
|
|
if (node) {
|
|
node.children.forEach(function (child) { return map$$1[child.value.outlet] = child; });
|
|
}
|
|
return map$$1;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Represents the state of the router.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@Component({templateUrl:'template.html'})
|
|
* class MyComponent {
|
|
* constructor(router: Router) {
|
|
* const state: RouterState = router.routerState;
|
|
* const root: ActivatedRoute = state.root;
|
|
* const child = root.firstChild;
|
|
* const id: Observable<string> = child.params.map(p => p.id);
|
|
* //...
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@description
|
|
* RouterState is a tree of activated routes. Every node in this tree knows about the "consumed" URL
|
|
* segments, the extracted parameters, and the resolved data.
|
|
*
|
|
* See {\@link ActivatedRoute} for more information.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterState = /** @class */ (function (_super) {
|
|
__extends(RouterState, _super);
|
|
/** @internal */
|
|
function RouterState(root, snapshot) {
|
|
var _this = _super.call(this, root) || this;
|
|
_this.snapshot = snapshot;
|
|
setRouterState(/** @type {?} */ (_this), root);
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterState.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return this.snapshot.toString(); };
|
|
return RouterState;
|
|
}(Tree));
|
|
/**
|
|
* @param {?} urlTree
|
|
* @param {?} rootComponent
|
|
* @return {?}
|
|
*/
|
|
function createEmptyState(urlTree, rootComponent) {
|
|
var /** @type {?} */ snapshot = createEmptyStateSnapshot(urlTree, rootComponent);
|
|
var /** @type {?} */ emptyUrl = new rxjs_BehaviorSubject.BehaviorSubject([new UrlSegment('', {})]);
|
|
var /** @type {?} */ emptyParams = new rxjs_BehaviorSubject.BehaviorSubject({});
|
|
var /** @type {?} */ emptyData = new rxjs_BehaviorSubject.BehaviorSubject({});
|
|
var /** @type {?} */ emptyQueryParams = new rxjs_BehaviorSubject.BehaviorSubject({});
|
|
var /** @type {?} */ fragment = new rxjs_BehaviorSubject.BehaviorSubject('');
|
|
var /** @type {?} */ activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);
|
|
activated.snapshot = snapshot.root;
|
|
return new RouterState(new TreeNode(activated, []), snapshot);
|
|
}
|
|
/**
|
|
* @param {?} urlTree
|
|
* @param {?} rootComponent
|
|
* @return {?}
|
|
*/
|
|
function createEmptyStateSnapshot(urlTree, rootComponent) {
|
|
var /** @type {?} */ emptyParams = {};
|
|
var /** @type {?} */ emptyData = {};
|
|
var /** @type {?} */ emptyQueryParams = {};
|
|
var /** @type {?} */ fragment = '';
|
|
var /** @type {?} */ activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, urlTree.root, -1, {});
|
|
return new RouterStateSnapshot('', new TreeNode(activated, []));
|
|
}
|
|
/**
|
|
* \@whatItDoes Contains the information about a route associated with a component loaded in an
|
|
* outlet.
|
|
* An `ActivatedRoute` can also be used to traverse the router state tree.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@Component({...})
|
|
* class MyComponent {
|
|
* constructor(route: ActivatedRoute) {
|
|
* const id: Observable<string> = route.params.map(p => p.id);
|
|
* const url: Observable<string> = route.url.map(segments => segments.join(''));
|
|
* // route.data includes both `data` and `resolve`
|
|
* const user = route.data.map(d => d.user);
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@stable
|
|
*/
|
|
var ActivatedRoute = /** @class */ (function () {
|
|
/** @internal */
|
|
function ActivatedRoute(url, params, queryParams, fragment, data, outlet, component, futureSnapshot) {
|
|
this.url = url;
|
|
this.params = params;
|
|
this.queryParams = queryParams;
|
|
this.fragment = fragment;
|
|
this.data = data;
|
|
this.outlet = outlet;
|
|
this.component = component;
|
|
this._futureSnapshot = futureSnapshot;
|
|
}
|
|
Object.defineProperty(ActivatedRoute.prototype, "routeConfig", {
|
|
/** The configuration used to match this route */
|
|
get: /**
|
|
* The configuration used to match this route
|
|
* @return {?}
|
|
*/
|
|
function () { return this._futureSnapshot.routeConfig; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "root", {
|
|
/** The root of the router state */
|
|
get: /**
|
|
* The root of the router state
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.root; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "parent", {
|
|
/** The parent of this route in the router state tree */
|
|
get: /**
|
|
* The parent of this route in the router state tree
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.parent(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "firstChild", {
|
|
/** The first child of this route in the router state tree */
|
|
get: /**
|
|
* The first child of this route in the router state tree
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.firstChild(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "children", {
|
|
/** The children of this route in the router state tree */
|
|
get: /**
|
|
* The children of this route in the router state tree
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.children(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "pathFromRoot", {
|
|
/** The path from the root of the router state tree to this route */
|
|
get: /**
|
|
* The path from the root of the router state tree to this route
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.pathFromRoot(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "paramMap", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this._paramMap) {
|
|
this._paramMap = rxjs_operator_map.map.call(this.params, function (p) { return convertToParamMap(p); });
|
|
}
|
|
return this._paramMap;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRoute.prototype, "queryParamMap", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this._queryParamMap) {
|
|
this._queryParamMap =
|
|
rxjs_operator_map.map.call(this.queryParams, function (p) { return convertToParamMap(p); });
|
|
}
|
|
return this._queryParamMap;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ActivatedRoute.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.snapshot ? this.snapshot.toString() : "Future(" + this._futureSnapshot + ")";
|
|
};
|
|
return ActivatedRoute;
|
|
}());
|
|
/**
|
|
* Returns the inherited params, data, and resolve for a given route.
|
|
* By default, this only inherits values up to the nearest path-less or component-less route.
|
|
* \@internal
|
|
* @param {?} route
|
|
* @param {?=} paramsInheritanceStrategy
|
|
* @return {?}
|
|
*/
|
|
function inheritedParamsDataResolve(route, paramsInheritanceStrategy) {
|
|
if (paramsInheritanceStrategy === void 0) { paramsInheritanceStrategy = 'emptyOnly'; }
|
|
var /** @type {?} */ pathFromRoot = route.pathFromRoot;
|
|
var /** @type {?} */ inheritingStartingFrom = 0;
|
|
if (paramsInheritanceStrategy !== 'always') {
|
|
inheritingStartingFrom = pathFromRoot.length - 1;
|
|
while (inheritingStartingFrom >= 1) {
|
|
var /** @type {?} */ current = pathFromRoot[inheritingStartingFrom];
|
|
var /** @type {?} */ parent_1 = pathFromRoot[inheritingStartingFrom - 1];
|
|
// current route is an empty path => inherits its parent's params and data
|
|
if (current.routeConfig && current.routeConfig.path === '') {
|
|
inheritingStartingFrom--;
|
|
// parent is componentless => current route should inherit its params and data
|
|
}
|
|
else if (!parent_1.component) {
|
|
inheritingStartingFrom--;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return flattenInherited(pathFromRoot.slice(inheritingStartingFrom));
|
|
}
|
|
/**
|
|
* \@internal
|
|
* @param {?} pathFromRoot
|
|
* @return {?}
|
|
*/
|
|
function flattenInherited(pathFromRoot) {
|
|
return pathFromRoot.reduce(function (res, curr) {
|
|
var /** @type {?} */ params = __assign({}, res.params, curr.params);
|
|
var /** @type {?} */ data = __assign({}, res.data, curr.data);
|
|
var /** @type {?} */ resolve = __assign({}, res.resolve, curr._resolvedData);
|
|
return { params: params, data: data, resolve: resolve };
|
|
}, /** @type {?} */ ({ params: {}, data: {}, resolve: {} }));
|
|
}
|
|
/**
|
|
* \@whatItDoes Contains the information about a route associated with a component loaded in an
|
|
* outlet
|
|
* at a particular moment in time. ActivatedRouteSnapshot can also be used to traverse the router
|
|
* state tree.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@Component({templateUrl:'./my-component.html'})
|
|
* class MyComponent {
|
|
* constructor(route: ActivatedRoute) {
|
|
* const id: string = route.snapshot.params.id;
|
|
* const url: string = route.snapshot.url.join('');
|
|
* const user = route.snapshot.data.user;
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@stable
|
|
*/
|
|
var ActivatedRouteSnapshot = /** @class */ (function () {
|
|
/** @internal */
|
|
function ActivatedRouteSnapshot(url, params, queryParams, fragment, data, outlet, component, routeConfig, urlSegment, lastPathIndex, resolve) {
|
|
this.url = url;
|
|
this.params = params;
|
|
this.queryParams = queryParams;
|
|
this.fragment = fragment;
|
|
this.data = data;
|
|
this.outlet = outlet;
|
|
this.component = component;
|
|
this.routeConfig = routeConfig;
|
|
this._urlSegment = urlSegment;
|
|
this._lastPathIndex = lastPathIndex;
|
|
this._resolve = resolve;
|
|
}
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "root", {
|
|
/** The root of the router state */
|
|
get: /**
|
|
* The root of the router state
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.root; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "parent", {
|
|
/** The parent of this route in the router state tree */
|
|
get: /**
|
|
* The parent of this route in the router state tree
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.parent(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "firstChild", {
|
|
/** The first child of this route in the router state tree */
|
|
get: /**
|
|
* The first child of this route in the router state tree
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.firstChild(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "children", {
|
|
/** The children of this route in the router state tree */
|
|
get: /**
|
|
* The children of this route in the router state tree
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.children(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "pathFromRoot", {
|
|
/** The path from the root of the router state tree to this route */
|
|
get: /**
|
|
* The path from the root of the router state tree to this route
|
|
* @return {?}
|
|
*/
|
|
function () { return this._routerState.pathFromRoot(this); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "paramMap", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this._paramMap) {
|
|
this._paramMap = convertToParamMap(this.params);
|
|
}
|
|
return this._paramMap;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(ActivatedRouteSnapshot.prototype, "queryParamMap", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this._queryParamMap) {
|
|
this._queryParamMap = convertToParamMap(this.queryParams);
|
|
}
|
|
return this._queryParamMap;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
ActivatedRouteSnapshot.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ url = this.url.map(function (segment) { return segment.toString(); }).join('/');
|
|
var /** @type {?} */ matched = this.routeConfig ? this.routeConfig.path : '';
|
|
return "Route(url:'" + url + "', path:'" + matched + "')";
|
|
};
|
|
return ActivatedRouteSnapshot;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Represents the state of the router at a moment in time.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@Component({templateUrl:'template.html'})
|
|
* class MyComponent {
|
|
* constructor(router: Router) {
|
|
* const state: RouterState = router.routerState;
|
|
* const snapshot: RouterStateSnapshot = state.snapshot;
|
|
* const root: ActivatedRouteSnapshot = snapshot.root;
|
|
* const child = root.firstChild;
|
|
* const id: Observable<string> = child.params.map(p => p.id);
|
|
* //...
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* \@description
|
|
* RouterStateSnapshot is a tree of activated route snapshots. Every node in this tree knows about
|
|
* the "consumed" URL segments, the extracted parameters, and the resolved data.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterStateSnapshot = /** @class */ (function (_super) {
|
|
__extends(RouterStateSnapshot, _super);
|
|
/** @internal */
|
|
function RouterStateSnapshot(url, root) {
|
|
var _this = _super.call(this, root) || this;
|
|
_this.url = url;
|
|
setRouterState(/** @type {?} */ (_this), root);
|
|
return _this;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterStateSnapshot.prototype.toString = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return serializeNode(this._root); };
|
|
return RouterStateSnapshot;
|
|
}(Tree));
|
|
/**
|
|
* @template U, T
|
|
* @param {?} state
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
function setRouterState(state, node) {
|
|
node.value._routerState = state;
|
|
node.children.forEach(function (c) { return setRouterState(state, c); });
|
|
}
|
|
/**
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
function serializeNode(node) {
|
|
var /** @type {?} */ c = node.children.length > 0 ? " { " + node.children.map(serializeNode).join(', ') + " } " : '';
|
|
return "" + node.value + c;
|
|
}
|
|
/**
|
|
* The expectation is that the activate route is created with the right set of parameters.
|
|
* So we push new values into the observables only when they are not the initial values.
|
|
* And we detect that by checking if the snapshot field is set.
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function advanceActivatedRoute(route) {
|
|
if (route.snapshot) {
|
|
var /** @type {?} */ currentSnapshot = route.snapshot;
|
|
var /** @type {?} */ nextSnapshot = route._futureSnapshot;
|
|
route.snapshot = nextSnapshot;
|
|
if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
|
|
(/** @type {?} */ (route.queryParams)).next(nextSnapshot.queryParams);
|
|
}
|
|
if (currentSnapshot.fragment !== nextSnapshot.fragment) {
|
|
(/** @type {?} */ (route.fragment)).next(nextSnapshot.fragment);
|
|
}
|
|
if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
|
|
(/** @type {?} */ (route.params)).next(nextSnapshot.params);
|
|
}
|
|
if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
|
|
(/** @type {?} */ (route.url)).next(nextSnapshot.url);
|
|
}
|
|
if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
|
|
(/** @type {?} */ (route.data)).next(nextSnapshot.data);
|
|
}
|
|
}
|
|
else {
|
|
route.snapshot = route._futureSnapshot;
|
|
// this is for resolved data
|
|
(/** @type {?} */ (route.data)).next(route._futureSnapshot.data);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} a
|
|
* @param {?} b
|
|
* @return {?}
|
|
*/
|
|
function equalParamsAndUrlSegments(a, b) {
|
|
var /** @type {?} */ equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);
|
|
var /** @type {?} */ parentsMismatch = !a.parent !== !b.parent;
|
|
return equalUrlParams && !parentsMismatch &&
|
|
(!a.parent || equalParamsAndUrlSegments(a.parent, /** @type {?} */ ((b.parent))));
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* @param {?} routeReuseStrategy
|
|
* @param {?} curr
|
|
* @param {?} prevState
|
|
* @return {?}
|
|
*/
|
|
function createRouterState(routeReuseStrategy, curr, prevState) {
|
|
var /** @type {?} */ root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : undefined);
|
|
return new RouterState(root, curr);
|
|
}
|
|
/**
|
|
* @param {?} routeReuseStrategy
|
|
* @param {?} curr
|
|
* @param {?=} prevState
|
|
* @return {?}
|
|
*/
|
|
function createNode(routeReuseStrategy, curr, prevState) {
|
|
// reuse an activated route that is currently displayed on the screen
|
|
if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
|
|
var /** @type {?} */ value = prevState.value;
|
|
value._futureSnapshot = curr.value;
|
|
var /** @type {?} */ children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
|
|
return new TreeNode(value, children);
|
|
// retrieve an activated route that is used to be displayed, but is not currently displayed
|
|
}
|
|
else if (routeReuseStrategy.retrieve(curr.value)) {
|
|
var /** @type {?} */ tree = (/** @type {?} */ (routeReuseStrategy.retrieve(curr.value))).route;
|
|
setFutureSnapshotsOfActivatedRoutes(curr, tree);
|
|
return tree;
|
|
}
|
|
else {
|
|
var /** @type {?} */ value = createActivatedRoute(curr.value);
|
|
var /** @type {?} */ children = curr.children.map(function (c) { return createNode(routeReuseStrategy, c); });
|
|
return new TreeNode(value, children);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} curr
|
|
* @param {?} result
|
|
* @return {?}
|
|
*/
|
|
function setFutureSnapshotsOfActivatedRoutes(curr, result) {
|
|
if (curr.value.routeConfig !== result.value.routeConfig) {
|
|
throw new Error('Cannot reattach ActivatedRouteSnapshot created from a different route');
|
|
}
|
|
if (curr.children.length !== result.children.length) {
|
|
throw new Error('Cannot reattach ActivatedRouteSnapshot with a different number of children');
|
|
}
|
|
result.value._futureSnapshot = curr.value;
|
|
for (var /** @type {?} */ i = 0; i < curr.children.length; ++i) {
|
|
setFutureSnapshotsOfActivatedRoutes(curr.children[i], result.children[i]);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} routeReuseStrategy
|
|
* @param {?} curr
|
|
* @param {?} prevState
|
|
* @return {?}
|
|
*/
|
|
function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
|
|
return curr.children.map(function (child) {
|
|
for (var _i = 0, _a = prevState.children; _i < _a.length; _i++) {
|
|
var p = _a[_i];
|
|
if (routeReuseStrategy.shouldReuseRoute(p.value.snapshot, child.value)) {
|
|
return createNode(routeReuseStrategy, child, p);
|
|
}
|
|
}
|
|
return createNode(routeReuseStrategy, child);
|
|
});
|
|
}
|
|
/**
|
|
* @param {?} c
|
|
* @return {?}
|
|
*/
|
|
function createActivatedRoute(c) {
|
|
return new ActivatedRoute(new rxjs_BehaviorSubject.BehaviorSubject(c.url), new rxjs_BehaviorSubject.BehaviorSubject(c.params), new rxjs_BehaviorSubject.BehaviorSubject(c.queryParams), new rxjs_BehaviorSubject.BehaviorSubject(c.fragment), new rxjs_BehaviorSubject.BehaviorSubject(c.data), c.outlet, c.component, c);
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} urlTree
|
|
* @param {?} commands
|
|
* @param {?} queryParams
|
|
* @param {?} fragment
|
|
* @return {?}
|
|
*/
|
|
function createUrlTree(route, urlTree, commands, queryParams, fragment) {
|
|
if (commands.length === 0) {
|
|
return tree(urlTree.root, urlTree.root, urlTree, queryParams, fragment);
|
|
}
|
|
var /** @type {?} */ nav = computeNavigation(commands);
|
|
if (nav.toRoot()) {
|
|
return tree(urlTree.root, new UrlSegmentGroup([], {}), urlTree, queryParams, fragment);
|
|
}
|
|
var /** @type {?} */ startingPosition = findStartingPosition(nav, urlTree, route);
|
|
var /** @type {?} */ segmentGroup = startingPosition.processChildren ?
|
|
updateSegmentGroupChildren(startingPosition.segmentGroup, startingPosition.index, nav.commands) :
|
|
updateSegmentGroup(startingPosition.segmentGroup, startingPosition.index, nav.commands);
|
|
return tree(startingPosition.segmentGroup, segmentGroup, urlTree, queryParams, fragment);
|
|
}
|
|
/**
|
|
* @param {?} command
|
|
* @return {?}
|
|
*/
|
|
function isMatrixParams(command) {
|
|
return typeof command === 'object' && command != null && !command.outlets && !command.segmentPath;
|
|
}
|
|
/**
|
|
* @param {?} oldSegmentGroup
|
|
* @param {?} newSegmentGroup
|
|
* @param {?} urlTree
|
|
* @param {?} queryParams
|
|
* @param {?} fragment
|
|
* @return {?}
|
|
*/
|
|
function tree(oldSegmentGroup, newSegmentGroup, urlTree, queryParams, fragment) {
|
|
var /** @type {?} */ qp = {};
|
|
if (queryParams) {
|
|
forEach(queryParams, function (value, name) {
|
|
qp[name] = Array.isArray(value) ? value.map(function (v) { return "" + v; }) : "" + value;
|
|
});
|
|
}
|
|
if (urlTree.root === oldSegmentGroup) {
|
|
return new UrlTree(newSegmentGroup, qp, fragment);
|
|
}
|
|
return new UrlTree(replaceSegment(urlTree.root, oldSegmentGroup, newSegmentGroup), qp, fragment);
|
|
}
|
|
/**
|
|
* @param {?} current
|
|
* @param {?} oldSegment
|
|
* @param {?} newSegment
|
|
* @return {?}
|
|
*/
|
|
function replaceSegment(current, oldSegment, newSegment) {
|
|
var /** @type {?} */ children = {};
|
|
forEach(current.children, function (c, outletName) {
|
|
if (c === oldSegment) {
|
|
children[outletName] = newSegment;
|
|
}
|
|
else {
|
|
children[outletName] = replaceSegment(c, oldSegment, newSegment);
|
|
}
|
|
});
|
|
return new UrlSegmentGroup(current.segments, children);
|
|
}
|
|
var Navigation = /** @class */ (function () {
|
|
function Navigation(isAbsolute, numberOfDoubleDots, commands) {
|
|
this.isAbsolute = isAbsolute;
|
|
this.numberOfDoubleDots = numberOfDoubleDots;
|
|
this.commands = commands;
|
|
if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
|
|
throw new Error('Root segment cannot have matrix parameters');
|
|
}
|
|
var /** @type {?} */ cmdWithOutlet = commands.find(function (c) { return typeof c === 'object' && c != null && c.outlets; });
|
|
if (cmdWithOutlet && cmdWithOutlet !== last$1(commands)) {
|
|
throw new Error('{outlets:{}} has to be the last command');
|
|
}
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
Navigation.prototype.toRoot = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.isAbsolute && this.commands.length === 1 && this.commands[0] == '/';
|
|
};
|
|
return Navigation;
|
|
}());
|
|
/**
|
|
* Transforms commands to a normalized `Navigation`
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function computeNavigation(commands) {
|
|
if ((typeof commands[0] === 'string') && commands.length === 1 && commands[0] === '/') {
|
|
return new Navigation(true, 0, commands);
|
|
}
|
|
var /** @type {?} */ numberOfDoubleDots = 0;
|
|
var /** @type {?} */ isAbsolute = false;
|
|
var /** @type {?} */ res = commands.reduce(function (res, cmd, cmdIdx) {
|
|
if (typeof cmd === 'object' && cmd != null) {
|
|
if (cmd.outlets) {
|
|
var /** @type {?} */ outlets_1 = {};
|
|
forEach(cmd.outlets, function (commands, name) {
|
|
outlets_1[name] = typeof commands === 'string' ? commands.split('/') : commands;
|
|
});
|
|
return res.concat([{ outlets: outlets_1 }]);
|
|
}
|
|
if (cmd.segmentPath) {
|
|
return res.concat([cmd.segmentPath]);
|
|
}
|
|
}
|
|
if (!(typeof cmd === 'string')) {
|
|
return res.concat([cmd]);
|
|
}
|
|
if (cmdIdx === 0) {
|
|
cmd.split('/').forEach(function (urlPart, partIndex) {
|
|
if (partIndex == 0 && urlPart === '.') {
|
|
// skip './a'
|
|
}
|
|
else if (partIndex == 0 && urlPart === '') {
|
|
// '/a'
|
|
isAbsolute = true;
|
|
}
|
|
else if (urlPart === '..') {
|
|
// '../a'
|
|
numberOfDoubleDots++;
|
|
}
|
|
else if (urlPart != '') {
|
|
res.push(urlPart);
|
|
}
|
|
});
|
|
return res;
|
|
}
|
|
return res.concat([cmd]);
|
|
}, []);
|
|
return new Navigation(isAbsolute, numberOfDoubleDots, res);
|
|
}
|
|
var Position = /** @class */ (function () {
|
|
function Position(segmentGroup, processChildren, index) {
|
|
this.segmentGroup = segmentGroup;
|
|
this.processChildren = processChildren;
|
|
this.index = index;
|
|
}
|
|
return Position;
|
|
}());
|
|
/**
|
|
* @param {?} nav
|
|
* @param {?} tree
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function findStartingPosition(nav, tree, route) {
|
|
if (nav.isAbsolute) {
|
|
return new Position(tree.root, true, 0);
|
|
}
|
|
if (route.snapshot._lastPathIndex === -1) {
|
|
return new Position(route.snapshot._urlSegment, true, 0);
|
|
}
|
|
var /** @type {?} */ modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;
|
|
var /** @type {?} */ index = route.snapshot._lastPathIndex + modifier;
|
|
return createPositionApplyingDoubleDots(route.snapshot._urlSegment, index, nav.numberOfDoubleDots);
|
|
}
|
|
/**
|
|
* @param {?} group
|
|
* @param {?} index
|
|
* @param {?} numberOfDoubleDots
|
|
* @return {?}
|
|
*/
|
|
function createPositionApplyingDoubleDots(group, index, numberOfDoubleDots) {
|
|
var /** @type {?} */ g = group;
|
|
var /** @type {?} */ ci = index;
|
|
var /** @type {?} */ dd = numberOfDoubleDots;
|
|
while (dd > ci) {
|
|
dd -= ci;
|
|
g = /** @type {?} */ ((g.parent));
|
|
if (!g) {
|
|
throw new Error('Invalid number of \'../\'');
|
|
}
|
|
ci = g.segments.length;
|
|
}
|
|
return new Position(g, false, ci - dd);
|
|
}
|
|
/**
|
|
* @param {?} command
|
|
* @return {?}
|
|
*/
|
|
function getPath(command) {
|
|
if (typeof command === 'object' && command != null && command.outlets) {
|
|
return command.outlets[PRIMARY_OUTLET];
|
|
}
|
|
return "" + command;
|
|
}
|
|
/**
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function getOutlets(commands) {
|
|
if (!(typeof commands[0] === 'object'))
|
|
return _a = {}, _a[PRIMARY_OUTLET] = commands, _a;
|
|
if (commands[0].outlets === undefined)
|
|
return _b = {}, _b[PRIMARY_OUTLET] = commands, _b;
|
|
return commands[0].outlets;
|
|
var _a, _b;
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} startIndex
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function updateSegmentGroup(segmentGroup, startIndex, commands) {
|
|
if (!segmentGroup) {
|
|
segmentGroup = new UrlSegmentGroup([], {});
|
|
}
|
|
if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
|
|
return updateSegmentGroupChildren(segmentGroup, startIndex, commands);
|
|
}
|
|
var /** @type {?} */ m = prefixedWith(segmentGroup, startIndex, commands);
|
|
var /** @type {?} */ slicedCommands = commands.slice(m.commandIndex);
|
|
if (m.match && m.pathIndex < segmentGroup.segments.length) {
|
|
var /** @type {?} */ g = new UrlSegmentGroup(segmentGroup.segments.slice(0, m.pathIndex), {});
|
|
g.children[PRIMARY_OUTLET] =
|
|
new UrlSegmentGroup(segmentGroup.segments.slice(m.pathIndex), segmentGroup.children);
|
|
return updateSegmentGroupChildren(g, 0, slicedCommands);
|
|
}
|
|
else if (m.match && slicedCommands.length === 0) {
|
|
return new UrlSegmentGroup(segmentGroup.segments, {});
|
|
}
|
|
else if (m.match && !segmentGroup.hasChildren()) {
|
|
return createNewSegmentGroup(segmentGroup, startIndex, commands);
|
|
}
|
|
else if (m.match) {
|
|
return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);
|
|
}
|
|
else {
|
|
return createNewSegmentGroup(segmentGroup, startIndex, commands);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} startIndex
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function updateSegmentGroupChildren(segmentGroup, startIndex, commands) {
|
|
if (commands.length === 0) {
|
|
return new UrlSegmentGroup(segmentGroup.segments, {});
|
|
}
|
|
else {
|
|
var /** @type {?} */ outlets_2 = getOutlets(commands);
|
|
var /** @type {?} */ children_1 = {};
|
|
forEach(outlets_2, function (commands, outlet) {
|
|
if (commands !== null) {
|
|
children_1[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands);
|
|
}
|
|
});
|
|
forEach(segmentGroup.children, function (child, childOutlet) {
|
|
if (outlets_2[childOutlet] === undefined) {
|
|
children_1[childOutlet] = child;
|
|
}
|
|
});
|
|
return new UrlSegmentGroup(segmentGroup.segments, children_1);
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} startIndex
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function prefixedWith(segmentGroup, startIndex, commands) {
|
|
var /** @type {?} */ currentCommandIndex = 0;
|
|
var /** @type {?} */ currentPathIndex = startIndex;
|
|
var /** @type {?} */ noMatch = { match: false, pathIndex: 0, commandIndex: 0 };
|
|
while (currentPathIndex < segmentGroup.segments.length) {
|
|
if (currentCommandIndex >= commands.length)
|
|
return noMatch;
|
|
var /** @type {?} */ path = segmentGroup.segments[currentPathIndex];
|
|
var /** @type {?} */ curr = getPath(commands[currentCommandIndex]);
|
|
var /** @type {?} */ next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;
|
|
if (currentPathIndex > 0 && curr === undefined)
|
|
break;
|
|
if (curr && next && (typeof next === 'object') && next.outlets === undefined) {
|
|
if (!compare(curr, next, path))
|
|
return noMatch;
|
|
currentCommandIndex += 2;
|
|
}
|
|
else {
|
|
if (!compare(curr, {}, path))
|
|
return noMatch;
|
|
currentCommandIndex++;
|
|
}
|
|
currentPathIndex++;
|
|
}
|
|
return { match: true, pathIndex: currentPathIndex, commandIndex: currentCommandIndex };
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} startIndex
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function createNewSegmentGroup(segmentGroup, startIndex, commands) {
|
|
var /** @type {?} */ paths = segmentGroup.segments.slice(0, startIndex);
|
|
var /** @type {?} */ i = 0;
|
|
while (i < commands.length) {
|
|
if (typeof commands[i] === 'object' && commands[i].outlets !== undefined) {
|
|
var /** @type {?} */ children = createNewSegmentChildren(commands[i].outlets);
|
|
return new UrlSegmentGroup(paths, children);
|
|
}
|
|
// if we start with an object literal, we need to reuse the path part from the segment
|
|
if (i === 0 && isMatrixParams(commands[0])) {
|
|
var /** @type {?} */ p = segmentGroup.segments[startIndex];
|
|
paths.push(new UrlSegment(p.path, commands[0]));
|
|
i++;
|
|
continue;
|
|
}
|
|
var /** @type {?} */ curr = getPath(commands[i]);
|
|
var /** @type {?} */ next = (i < commands.length - 1) ? commands[i + 1] : null;
|
|
if (curr && next && isMatrixParams(next)) {
|
|
paths.push(new UrlSegment(curr, stringify(next)));
|
|
i += 2;
|
|
}
|
|
else {
|
|
paths.push(new UrlSegment(curr, {}));
|
|
i++;
|
|
}
|
|
}
|
|
return new UrlSegmentGroup(paths, {});
|
|
}
|
|
/**
|
|
* @param {?} outlets
|
|
* @return {?}
|
|
*/
|
|
function createNewSegmentChildren(outlets) {
|
|
var /** @type {?} */ children = {};
|
|
forEach(outlets, function (commands, outlet) {
|
|
if (commands !== null) {
|
|
children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);
|
|
}
|
|
});
|
|
return children;
|
|
}
|
|
/**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function stringify(params) {
|
|
var /** @type {?} */ res = {};
|
|
forEach(params, function (v, k) { return res[k] = "" + v; });
|
|
return res;
|
|
}
|
|
/**
|
|
* @param {?} path
|
|
* @param {?} params
|
|
* @param {?} segment
|
|
* @return {?}
|
|
*/
|
|
function compare(path, params, segment) {
|
|
return path == segment.path && shallowEqual(params, segment.parameters);
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
var CanActivate = /** @class */ (function () {
|
|
function CanActivate(path) {
|
|
this.path = path;
|
|
this.route = this.path[this.path.length - 1];
|
|
}
|
|
return CanActivate;
|
|
}());
|
|
var CanDeactivate = /** @class */ (function () {
|
|
function CanDeactivate(component, route) {
|
|
this.component = component;
|
|
this.route = route;
|
|
}
|
|
return CanDeactivate;
|
|
}());
|
|
/**
|
|
* This class bundles the actions involved in preactivation of a route.
|
|
*/
|
|
var PreActivation = /** @class */ (function () {
|
|
function PreActivation(future, curr, moduleInjector, forwardEvent) {
|
|
this.future = future;
|
|
this.curr = curr;
|
|
this.moduleInjector = moduleInjector;
|
|
this.forwardEvent = forwardEvent;
|
|
this.canActivateChecks = [];
|
|
this.canDeactivateChecks = [];
|
|
}
|
|
/**
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.initialize = /**
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
function (parentContexts) {
|
|
var /** @type {?} */ futureRoot = this.future._root;
|
|
var /** @type {?} */ currRoot = this.curr ? this.curr._root : null;
|
|
this.setupChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.checkGuards = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
if (!this.isDeactivating() && !this.isActivating()) {
|
|
return rxjs_observable_of.of(true);
|
|
}
|
|
var /** @type {?} */ canDeactivate$ = this.runCanDeactivateChecks();
|
|
return rxjs_operator_mergeMap.mergeMap.call(canDeactivate$, function (canDeactivate) { return canDeactivate ? _this.runCanActivateChecks() : rxjs_observable_of.of(false); });
|
|
};
|
|
/**
|
|
* @param {?} paramsInheritanceStrategy
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.resolveData = /**
|
|
* @param {?} paramsInheritanceStrategy
|
|
* @return {?}
|
|
*/
|
|
function (paramsInheritanceStrategy) {
|
|
var _this = this;
|
|
if (!this.isActivating())
|
|
return rxjs_observable_of.of(null);
|
|
var /** @type {?} */ checks$ = rxjs_observable_from.from(this.canActivateChecks);
|
|
var /** @type {?} */ runningChecks$ = rxjs_operator_concatMap.concatMap.call(checks$, function (check) { return _this.runResolve(check.route, paramsInheritanceStrategy); });
|
|
return rxjs_operator_reduce.reduce.call(runningChecks$, function (_, __) { return _; });
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.isDeactivating = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return this.canDeactivateChecks.length !== 0; };
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.isActivating = /**
|
|
* @return {?}
|
|
*/
|
|
function () { return this.canActivateChecks.length !== 0; };
|
|
/**
|
|
* Iterates over child routes and calls recursive `setupRouteGuards` to get `this` instance in
|
|
* proper state to run `checkGuards()` method.
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} contexts
|
|
* @param {?} futurePath
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.setupChildRouteGuards = /**
|
|
* Iterates over child routes and calls recursive `setupRouteGuards` to get `this` instance in
|
|
* proper state to run `checkGuards()` method.
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} contexts
|
|
* @param {?} futurePath
|
|
* @return {?}
|
|
*/
|
|
function (futureNode, currNode, contexts, futurePath) {
|
|
var _this = this;
|
|
var /** @type {?} */ prevChildren = nodeChildrenAsMap(currNode);
|
|
// Process the children of the future route
|
|
futureNode.children.forEach(function (c) {
|
|
_this.setupRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]));
|
|
delete prevChildren[c.value.outlet];
|
|
});
|
|
// Process any children left from the current route (not active for the future route)
|
|
forEach(prevChildren, function (v, k) {
|
|
return _this.deactivateRouteAndItsChildren(v, /** @type {?} */ ((contexts)).getContext(k));
|
|
});
|
|
};
|
|
/**
|
|
* Iterates over child routes and calls recursive `setupRouteGuards` to get `this` instance in
|
|
* proper state to run `checkGuards()` method.
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} parentContexts
|
|
* @param {?} futurePath
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.setupRouteGuards = /**
|
|
* Iterates over child routes and calls recursive `setupRouteGuards` to get `this` instance in
|
|
* proper state to run `checkGuards()` method.
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} parentContexts
|
|
* @param {?} futurePath
|
|
* @return {?}
|
|
*/
|
|
function (futureNode, currNode, parentContexts, futurePath) {
|
|
var /** @type {?} */ future = futureNode.value;
|
|
var /** @type {?} */ curr = currNode ? currNode.value : null;
|
|
var /** @type {?} */ context = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;
|
|
// reusing the node
|
|
if (curr && future.routeConfig === curr.routeConfig) {
|
|
var /** @type {?} */ shouldRunGuardsAndResolvers = this.shouldRunGuardsAndResolvers(curr, future, /** @type {?} */ ((future.routeConfig)).runGuardsAndResolvers);
|
|
if (shouldRunGuardsAndResolvers) {
|
|
this.canActivateChecks.push(new CanActivate(futurePath));
|
|
}
|
|
else {
|
|
// we need to set the data
|
|
future.data = curr.data;
|
|
future._resolvedData = curr._resolvedData;
|
|
}
|
|
// If we have a component, we need to go through an outlet.
|
|
if (future.component) {
|
|
this.setupChildRouteGuards(futureNode, currNode, context ? context.children : null, futurePath);
|
|
// if we have a componentless route, we recurse but keep the same outlet map.
|
|
}
|
|
else {
|
|
this.setupChildRouteGuards(futureNode, currNode, parentContexts, futurePath);
|
|
}
|
|
if (shouldRunGuardsAndResolvers) {
|
|
var /** @type {?} */ outlet = /** @type {?} */ ((/** @type {?} */ ((context)).outlet));
|
|
this.canDeactivateChecks.push(new CanDeactivate(outlet.component, curr));
|
|
}
|
|
}
|
|
else {
|
|
if (curr) {
|
|
this.deactivateRouteAndItsChildren(currNode, context);
|
|
}
|
|
this.canActivateChecks.push(new CanActivate(futurePath));
|
|
// If we have a component, we need to go through an outlet.
|
|
if (future.component) {
|
|
this.setupChildRouteGuards(futureNode, null, context ? context.children : null, futurePath);
|
|
// if we have a componentless route, we recurse but keep the same outlet map.
|
|
}
|
|
else {
|
|
this.setupChildRouteGuards(futureNode, null, parentContexts, futurePath);
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} curr
|
|
* @param {?} future
|
|
* @param {?} mode
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.shouldRunGuardsAndResolvers = /**
|
|
* @param {?} curr
|
|
* @param {?} future
|
|
* @param {?} mode
|
|
* @return {?}
|
|
*/
|
|
function (curr, future, mode) {
|
|
switch (mode) {
|
|
case 'always':
|
|
return true;
|
|
case 'paramsOrQueryParamsChange':
|
|
return !equalParamsAndUrlSegments(curr, future) ||
|
|
!shallowEqual(curr.queryParams, future.queryParams);
|
|
case 'paramsChange':
|
|
default:
|
|
return !equalParamsAndUrlSegments(curr, future);
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} context
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.deactivateRouteAndItsChildren = /**
|
|
* @param {?} route
|
|
* @param {?} context
|
|
* @return {?}
|
|
*/
|
|
function (route, context) {
|
|
var _this = this;
|
|
var /** @type {?} */ children = nodeChildrenAsMap(route);
|
|
var /** @type {?} */ r = route.value;
|
|
forEach(children, function (node, childName) {
|
|
if (!r.component) {
|
|
_this.deactivateRouteAndItsChildren(node, context);
|
|
}
|
|
else if (context) {
|
|
_this.deactivateRouteAndItsChildren(node, context.children.getContext(childName));
|
|
}
|
|
else {
|
|
_this.deactivateRouteAndItsChildren(node, null);
|
|
}
|
|
});
|
|
if (!r.component) {
|
|
this.canDeactivateChecks.push(new CanDeactivate(null, r));
|
|
}
|
|
else if (context && context.outlet && context.outlet.isActivated) {
|
|
this.canDeactivateChecks.push(new CanDeactivate(context.outlet.component, r));
|
|
}
|
|
else {
|
|
this.canDeactivateChecks.push(new CanDeactivate(null, r));
|
|
}
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.runCanDeactivateChecks = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
var /** @type {?} */ checks$ = rxjs_observable_from.from(this.canDeactivateChecks);
|
|
var /** @type {?} */ runningChecks$ = rxjs_operator_mergeMap.mergeMap.call(checks$, function (check) { return _this.runCanDeactivate(check.component, check.route); });
|
|
return rxjs_operator_every.every.call(runningChecks$, function (result) { return result === true; });
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.runCanActivateChecks = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
var /** @type {?} */ checks$ = rxjs_observable_from.from(this.canActivateChecks);
|
|
var /** @type {?} */ runningChecks$ = rxjs_operator_concatMap.concatMap.call(checks$, function (check) {
|
|
return andObservables(rxjs_observable_from.from([
|
|
_this.fireChildActivationStart(check.route.parent), _this.fireActivationStart(check.route),
|
|
_this.runCanActivateChild(check.path), _this.runCanActivate(check.route)
|
|
]));
|
|
});
|
|
return rxjs_operator_every.every.call(runningChecks$, function (result) { return result === true; });
|
|
// this.fireChildActivationStart(check.path),
|
|
};
|
|
/**
|
|
* This should fire off `ActivationStart` events for each route being activated at this
|
|
* level.
|
|
* In other words, if you're activating `a` and `b` below, `path` will contain the
|
|
* `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
|
|
* return
|
|
* `true` so checks continue to run.
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.fireActivationStart = /**
|
|
* This should fire off `ActivationStart` events for each route being activated at this
|
|
* level.
|
|
* In other words, if you're activating `a` and `b` below, `path` will contain the
|
|
* `ActivatedRouteSnapshot`s for both and we will fire `ActivationStart` for both. Always
|
|
* return
|
|
* `true` so checks continue to run.
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
function (snapshot) {
|
|
if (snapshot !== null && this.forwardEvent) {
|
|
this.forwardEvent(new ActivationStart(snapshot));
|
|
}
|
|
return rxjs_observable_of.of(true);
|
|
};
|
|
/**
|
|
* This should fire off `ChildActivationStart` events for each route being activated at this
|
|
* level.
|
|
* In other words, if you're activating `a` and `b` below, `path` will contain the
|
|
* `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
|
|
* return
|
|
* `true` so checks continue to run.
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.fireChildActivationStart = /**
|
|
* This should fire off `ChildActivationStart` events for each route being activated at this
|
|
* level.
|
|
* In other words, if you're activating `a` and `b` below, `path` will contain the
|
|
* `ActivatedRouteSnapshot`s for both and we will fire `ChildActivationStart` for both. Always
|
|
* return
|
|
* `true` so checks continue to run.
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
function (snapshot) {
|
|
if (snapshot !== null && this.forwardEvent) {
|
|
this.forwardEvent(new ChildActivationStart(snapshot));
|
|
}
|
|
return rxjs_observable_of.of(true);
|
|
};
|
|
/**
|
|
* @param {?} future
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.runCanActivate = /**
|
|
* @param {?} future
|
|
* @return {?}
|
|
*/
|
|
function (future) {
|
|
var _this = this;
|
|
var /** @type {?} */ canActivate = future.routeConfig ? future.routeConfig.canActivate : null;
|
|
if (!canActivate || canActivate.length === 0)
|
|
return rxjs_observable_of.of(true);
|
|
var /** @type {?} */ obs = rxjs_operator_map.map.call(rxjs_observable_from.from(canActivate), function (c) {
|
|
var /** @type {?} */ guard = _this.getToken(c, future);
|
|
var /** @type {?} */ observable;
|
|
if (guard.canActivate) {
|
|
observable = wrapIntoObservable(guard.canActivate(future, _this.future));
|
|
}
|
|
else {
|
|
observable = wrapIntoObservable(guard(future, _this.future));
|
|
}
|
|
return rxjs_operator_first.first.call(observable);
|
|
});
|
|
return andObservables(obs);
|
|
};
|
|
/**
|
|
* @param {?} path
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.runCanActivateChild = /**
|
|
* @param {?} path
|
|
* @return {?}
|
|
*/
|
|
function (path) {
|
|
var _this = this;
|
|
var /** @type {?} */ future = path[path.length - 1];
|
|
var /** @type {?} */ canActivateChildGuards = path.slice(0, path.length - 1)
|
|
.reverse()
|
|
.map(function (p) { return _this.extractCanActivateChild(p); })
|
|
.filter(function (_) { return _ !== null; });
|
|
return andObservables(rxjs_operator_map.map.call(rxjs_observable_from.from(canActivateChildGuards), function (d) {
|
|
var /** @type {?} */ obs = rxjs_operator_map.map.call(rxjs_observable_from.from(d.guards), function (c) {
|
|
var /** @type {?} */ guard = _this.getToken(c, d.node);
|
|
var /** @type {?} */ observable;
|
|
if (guard.canActivateChild) {
|
|
observable = wrapIntoObservable(guard.canActivateChild(future, _this.future));
|
|
}
|
|
else {
|
|
observable = wrapIntoObservable(guard(future, _this.future));
|
|
}
|
|
return rxjs_operator_first.first.call(observable);
|
|
});
|
|
return andObservables(obs);
|
|
}));
|
|
};
|
|
/**
|
|
* @param {?} p
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.extractCanActivateChild = /**
|
|
* @param {?} p
|
|
* @return {?}
|
|
*/
|
|
function (p) {
|
|
var /** @type {?} */ canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;
|
|
if (!canActivateChild || canActivateChild.length === 0)
|
|
return null;
|
|
return { node: p, guards: canActivateChild };
|
|
};
|
|
/**
|
|
* @param {?} component
|
|
* @param {?} curr
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.runCanDeactivate = /**
|
|
* @param {?} component
|
|
* @param {?} curr
|
|
* @return {?}
|
|
*/
|
|
function (component, curr) {
|
|
var _this = this;
|
|
var /** @type {?} */ canDeactivate = curr && curr.routeConfig ? curr.routeConfig.canDeactivate : null;
|
|
if (!canDeactivate || canDeactivate.length === 0)
|
|
return rxjs_observable_of.of(true);
|
|
var /** @type {?} */ canDeactivate$ = rxjs_operator_mergeMap.mergeMap.call(rxjs_observable_from.from(canDeactivate), function (c) {
|
|
var /** @type {?} */ guard = _this.getToken(c, curr);
|
|
var /** @type {?} */ observable;
|
|
if (guard.canDeactivate) {
|
|
observable =
|
|
wrapIntoObservable(guard.canDeactivate(component, curr, _this.curr, _this.future));
|
|
}
|
|
else {
|
|
observable = wrapIntoObservable(guard(component, curr, _this.curr, _this.future));
|
|
}
|
|
return rxjs_operator_first.first.call(observable);
|
|
});
|
|
return rxjs_operator_every.every.call(canDeactivate$, function (result) { return result === true; });
|
|
};
|
|
/**
|
|
* @param {?} future
|
|
* @param {?} paramsInheritanceStrategy
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.runResolve = /**
|
|
* @param {?} future
|
|
* @param {?} paramsInheritanceStrategy
|
|
* @return {?}
|
|
*/
|
|
function (future, paramsInheritanceStrategy) {
|
|
var /** @type {?} */ resolve = future._resolve;
|
|
return rxjs_operator_map.map.call(this.resolveNode(resolve, future), function (resolvedData) {
|
|
future._resolvedData = resolvedData;
|
|
future.data = __assign({}, future.data, inheritedParamsDataResolve(future, paramsInheritanceStrategy).resolve);
|
|
return null;
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} resolve
|
|
* @param {?} future
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.resolveNode = /**
|
|
* @param {?} resolve
|
|
* @param {?} future
|
|
* @return {?}
|
|
*/
|
|
function (resolve, future) {
|
|
var _this = this;
|
|
var /** @type {?} */ keys = Object.keys(resolve);
|
|
if (keys.length === 0) {
|
|
return rxjs_observable_of.of({});
|
|
}
|
|
if (keys.length === 1) {
|
|
var /** @type {?} */ key_1 = keys[0];
|
|
return rxjs_operator_map.map.call(this.getResolver(resolve[key_1], future), function (value) {
|
|
return _a = {}, _a[key_1] = value, _a;
|
|
var _a;
|
|
});
|
|
}
|
|
var /** @type {?} */ data = {};
|
|
var /** @type {?} */ runningResolvers$ = rxjs_operator_mergeMap.mergeMap.call(rxjs_observable_from.from(keys), function (key) {
|
|
return rxjs_operator_map.map.call(_this.getResolver(resolve[key], future), function (value) {
|
|
data[key] = value;
|
|
return value;
|
|
});
|
|
});
|
|
return rxjs_operator_map.map.call(rxjs_operator_last.last.call(runningResolvers$), function () { return data; });
|
|
};
|
|
/**
|
|
* @param {?} injectionToken
|
|
* @param {?} future
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.getResolver = /**
|
|
* @param {?} injectionToken
|
|
* @param {?} future
|
|
* @return {?}
|
|
*/
|
|
function (injectionToken, future) {
|
|
var /** @type {?} */ resolver = this.getToken(injectionToken, future);
|
|
return resolver.resolve ? wrapIntoObservable(resolver.resolve(future, this.future)) :
|
|
wrapIntoObservable(resolver(future, this.future));
|
|
};
|
|
/**
|
|
* @param {?} token
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
PreActivation.prototype.getToken = /**
|
|
* @param {?} token
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
function (token, snapshot) {
|
|
var /** @type {?} */ config = closestLoadedConfig(snapshot);
|
|
var /** @type {?} */ injector = config ? config.module.injector : this.moduleInjector;
|
|
return injector.get(token);
|
|
};
|
|
return PreActivation;
|
|
}());
|
|
/**
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
function closestLoadedConfig(snapshot) {
|
|
if (!snapshot)
|
|
return null;
|
|
for (var /** @type {?} */ s = snapshot.parent; s; s = s.parent) {
|
|
var /** @type {?} */ route = s.routeConfig;
|
|
if (route && route._loadedConfig)
|
|
return route._loadedConfig;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
var NoMatch$1 = /** @class */ (function () {
|
|
function NoMatch() {
|
|
}
|
|
return NoMatch;
|
|
}());
|
|
/**
|
|
* @param {?} rootComponentType
|
|
* @param {?} config
|
|
* @param {?} urlTree
|
|
* @param {?} url
|
|
* @param {?=} paramsInheritanceStrategy
|
|
* @return {?}
|
|
*/
|
|
function recognize(rootComponentType, config, urlTree, url, paramsInheritanceStrategy) {
|
|
if (paramsInheritanceStrategy === void 0) { paramsInheritanceStrategy = 'emptyOnly'; }
|
|
return new Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy)
|
|
.recognize();
|
|
}
|
|
var Recognizer = /** @class */ (function () {
|
|
function Recognizer(rootComponentType, config, urlTree, url, paramsInheritanceStrategy) {
|
|
this.rootComponentType = rootComponentType;
|
|
this.config = config;
|
|
this.urlTree = urlTree;
|
|
this.url = url;
|
|
this.paramsInheritanceStrategy = paramsInheritanceStrategy;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.recognize = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
try {
|
|
var /** @type {?} */ rootSegmentGroup = split$1(this.urlTree.root, [], [], this.config).segmentGroup;
|
|
var /** @type {?} */ children = this.processSegmentGroup(this.config, rootSegmentGroup, PRIMARY_OUTLET);
|
|
var /** @type {?} */ root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(this.urlTree.queryParams), /** @type {?} */ ((this.urlTree.fragment)), {}, PRIMARY_OUTLET, this.rootComponentType, null, this.urlTree.root, -1, {});
|
|
var /** @type {?} */ rootNode = new TreeNode(root, children);
|
|
var /** @type {?} */ routeState = new RouterStateSnapshot(this.url, rootNode);
|
|
this.inheritParamsAndData(routeState._root);
|
|
return rxjs_observable_of.of(routeState);
|
|
}
|
|
catch (/** @type {?} */ e) {
|
|
return new rxjs_Observable.Observable(function (obs) { return obs.error(e); });
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} routeNode
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.inheritParamsAndData = /**
|
|
* @param {?} routeNode
|
|
* @return {?}
|
|
*/
|
|
function (routeNode) {
|
|
var _this = this;
|
|
var /** @type {?} */ route = routeNode.value;
|
|
var /** @type {?} */ i = inheritedParamsDataResolve(route, this.paramsInheritanceStrategy);
|
|
route.params = Object.freeze(i.params);
|
|
route.data = Object.freeze(i.data);
|
|
routeNode.children.forEach(function (n) { return _this.inheritParamsAndData(n); });
|
|
};
|
|
/**
|
|
* @param {?} config
|
|
* @param {?} segmentGroup
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.processSegmentGroup = /**
|
|
* @param {?} config
|
|
* @param {?} segmentGroup
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (config, segmentGroup, outlet) {
|
|
if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
|
|
return this.processChildren(config, segmentGroup);
|
|
}
|
|
return this.processSegment(config, segmentGroup, segmentGroup.segments, outlet);
|
|
};
|
|
/**
|
|
* @param {?} config
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.processChildren = /**
|
|
* @param {?} config
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
function (config, segmentGroup) {
|
|
var _this = this;
|
|
var /** @type {?} */ children = mapChildrenIntoArray(segmentGroup, function (child, childOutlet) { return _this.processSegmentGroup(config, child, childOutlet); });
|
|
checkOutletNameUniqueness(children);
|
|
sortActivatedRouteSnapshots(children);
|
|
return children;
|
|
};
|
|
/**
|
|
* @param {?} config
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.processSegment = /**
|
|
* @param {?} config
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (config, segmentGroup, segments, outlet) {
|
|
for (var _i = 0, config_1 = config; _i < config_1.length; _i++) {
|
|
var r = config_1[_i];
|
|
try {
|
|
return this.processSegmentAgainstRoute(r, segmentGroup, segments, outlet);
|
|
}
|
|
catch (/** @type {?} */ e) {
|
|
if (!(e instanceof NoMatch$1))
|
|
throw e;
|
|
}
|
|
}
|
|
if (this.noLeftoversInUrl(segmentGroup, segments, outlet)) {
|
|
return [];
|
|
}
|
|
throw new NoMatch$1();
|
|
};
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.noLeftoversInUrl = /**
|
|
* @param {?} segmentGroup
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (segmentGroup, segments, outlet) {
|
|
return segments.length === 0 && !segmentGroup.children[outlet];
|
|
};
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} rawSegment
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
Recognizer.prototype.processSegmentAgainstRoute = /**
|
|
* @param {?} route
|
|
* @param {?} rawSegment
|
|
* @param {?} segments
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (route, rawSegment, segments, outlet) {
|
|
if (route.redirectTo)
|
|
throw new NoMatch$1();
|
|
if ((route.outlet || PRIMARY_OUTLET) !== outlet)
|
|
throw new NoMatch$1();
|
|
var /** @type {?} */ snapshot;
|
|
var /** @type {?} */ consumedSegments = [];
|
|
var /** @type {?} */ rawSlicedSegments = [];
|
|
if (route.path === '**') {
|
|
var /** @type {?} */ params = segments.length > 0 ? /** @type {?} */ ((last$1(segments))).parameters : {};
|
|
snapshot = new ActivatedRouteSnapshot(segments, params, Object.freeze(this.urlTree.queryParams), /** @type {?} */ ((this.urlTree.fragment)), getData(route), outlet, /** @type {?} */ ((route.component)), route, getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + segments.length, getResolve(route));
|
|
}
|
|
else {
|
|
var /** @type {?} */ result = match$1(rawSegment, route, segments);
|
|
consumedSegments = result.consumedSegments;
|
|
rawSlicedSegments = segments.slice(result.lastChild);
|
|
snapshot = new ActivatedRouteSnapshot(consumedSegments, result.parameters, Object.freeze(this.urlTree.queryParams), /** @type {?} */ ((this.urlTree.fragment)), getData(route), outlet, /** @type {?} */ ((route.component)), route, getSourceSegmentGroup(rawSegment), getPathIndexShift(rawSegment) + consumedSegments.length, getResolve(route));
|
|
}
|
|
var /** @type {?} */ childConfig = getChildConfig(route);
|
|
var _a = split$1(rawSegment, consumedSegments, rawSlicedSegments, childConfig), segmentGroup = _a.segmentGroup, slicedSegments = _a.slicedSegments;
|
|
if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
|
|
var /** @type {?} */ children_1 = this.processChildren(childConfig, segmentGroup);
|
|
return [new TreeNode(snapshot, children_1)];
|
|
}
|
|
if (childConfig.length === 0 && slicedSegments.length === 0) {
|
|
return [new TreeNode(snapshot, [])];
|
|
}
|
|
var /** @type {?} */ children = this.processSegment(childConfig, segmentGroup, slicedSegments, PRIMARY_OUTLET);
|
|
return [new TreeNode(snapshot, children)];
|
|
};
|
|
return Recognizer;
|
|
}());
|
|
/**
|
|
* @param {?} nodes
|
|
* @return {?}
|
|
*/
|
|
function sortActivatedRouteSnapshots(nodes) {
|
|
nodes.sort(function (a, b) {
|
|
if (a.value.outlet === PRIMARY_OUTLET)
|
|
return -1;
|
|
if (b.value.outlet === PRIMARY_OUTLET)
|
|
return 1;
|
|
return a.value.outlet.localeCompare(b.value.outlet);
|
|
});
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function getChildConfig(route) {
|
|
if (route.children) {
|
|
return route.children;
|
|
}
|
|
if (route.loadChildren) {
|
|
return /** @type {?} */ ((route._loadedConfig)).routes;
|
|
}
|
|
return [];
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} route
|
|
* @param {?} segments
|
|
* @return {?}
|
|
*/
|
|
function match$1(segmentGroup, route, segments) {
|
|
if (route.path === '') {
|
|
if (route.pathMatch === 'full' && (segmentGroup.hasChildren() || segments.length > 0)) {
|
|
throw new NoMatch$1();
|
|
}
|
|
return { consumedSegments: [], lastChild: 0, parameters: {} };
|
|
}
|
|
var /** @type {?} */ matcher = route.matcher || defaultUrlMatcher;
|
|
var /** @type {?} */ res = matcher(segments, segmentGroup, route);
|
|
if (!res)
|
|
throw new NoMatch$1();
|
|
var /** @type {?} */ posParams = {};
|
|
forEach(/** @type {?} */ ((res.posParams)), function (v, k) { posParams[k] = v.path; });
|
|
var /** @type {?} */ parameters = res.consumed.length > 0 ? __assign({}, posParams, res.consumed[res.consumed.length - 1].parameters) :
|
|
posParams;
|
|
return { consumedSegments: res.consumed, lastChild: res.consumed.length, parameters: parameters };
|
|
}
|
|
/**
|
|
* @param {?} nodes
|
|
* @return {?}
|
|
*/
|
|
function checkOutletNameUniqueness(nodes) {
|
|
var /** @type {?} */ names = {};
|
|
nodes.forEach(function (n) {
|
|
var /** @type {?} */ routeWithSameOutletName = names[n.value.outlet];
|
|
if (routeWithSameOutletName) {
|
|
var /** @type {?} */ p = routeWithSameOutletName.url.map(function (s) { return s.toString(); }).join('/');
|
|
var /** @type {?} */ c = n.value.url.map(function (s) { return s.toString(); }).join('/');
|
|
throw new Error("Two segments cannot have the same outlet name: '" + p + "' and '" + c + "'.");
|
|
}
|
|
names[n.value.outlet] = n.value;
|
|
});
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
function getSourceSegmentGroup(segmentGroup) {
|
|
var /** @type {?} */ s = segmentGroup;
|
|
while (s._sourceSegment) {
|
|
s = s._sourceSegment;
|
|
}
|
|
return s;
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @return {?}
|
|
*/
|
|
function getPathIndexShift(segmentGroup) {
|
|
var /** @type {?} */ s = segmentGroup;
|
|
var /** @type {?} */ res = (s._segmentIndexShift ? s._segmentIndexShift : 0);
|
|
while (s._sourceSegment) {
|
|
s = s._sourceSegment;
|
|
res += (s._segmentIndexShift ? s._segmentIndexShift : 0);
|
|
}
|
|
return res - 1;
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} consumedSegments
|
|
* @param {?} slicedSegments
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
function split$1(segmentGroup, consumedSegments, slicedSegments, config) {
|
|
if (slicedSegments.length > 0 &&
|
|
containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config)) {
|
|
var /** @type {?} */ s_1 = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(segmentGroup, consumedSegments, config, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
|
|
s_1._sourceSegment = segmentGroup;
|
|
s_1._segmentIndexShift = consumedSegments.length;
|
|
return { segmentGroup: s_1, slicedSegments: [] };
|
|
}
|
|
if (slicedSegments.length === 0 &&
|
|
containsEmptyPathMatches(segmentGroup, slicedSegments, config)) {
|
|
var /** @type {?} */ s_2 = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, config, segmentGroup.children));
|
|
s_2._sourceSegment = segmentGroup;
|
|
s_2._segmentIndexShift = consumedSegments.length;
|
|
return { segmentGroup: s_2, slicedSegments: slicedSegments };
|
|
}
|
|
var /** @type {?} */ s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
|
|
s._sourceSegment = segmentGroup;
|
|
s._segmentIndexShift = consumedSegments.length;
|
|
return { segmentGroup: s, slicedSegments: slicedSegments };
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} slicedSegments
|
|
* @param {?} routes
|
|
* @param {?} children
|
|
* @return {?}
|
|
*/
|
|
function addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, routes, children) {
|
|
var /** @type {?} */ res = {};
|
|
for (var _i = 0, routes_1 = routes; _i < routes_1.length; _i++) {
|
|
var r = routes_1[_i];
|
|
if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet$1(r)]) {
|
|
var /** @type {?} */ s = new UrlSegmentGroup([], {});
|
|
s._sourceSegment = segmentGroup;
|
|
s._segmentIndexShift = segmentGroup.segments.length;
|
|
res[getOutlet$1(r)] = s;
|
|
}
|
|
}
|
|
return __assign({}, children, res);
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} consumedSegments
|
|
* @param {?} routes
|
|
* @param {?} primarySegment
|
|
* @return {?}
|
|
*/
|
|
function createChildrenForEmptyPaths(segmentGroup, consumedSegments, routes, primarySegment) {
|
|
var /** @type {?} */ res = {};
|
|
res[PRIMARY_OUTLET] = primarySegment;
|
|
primarySegment._sourceSegment = segmentGroup;
|
|
primarySegment._segmentIndexShift = consumedSegments.length;
|
|
for (var _i = 0, routes_2 = routes; _i < routes_2.length; _i++) {
|
|
var r = routes_2[_i];
|
|
if (r.path === '' && getOutlet$1(r) !== PRIMARY_OUTLET) {
|
|
var /** @type {?} */ s = new UrlSegmentGroup([], {});
|
|
s._sourceSegment = segmentGroup;
|
|
s._segmentIndexShift = consumedSegments.length;
|
|
res[getOutlet$1(r)] = s;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} slicedSegments
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes) {
|
|
return routes.some(function (r) { return emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet$1(r) !== PRIMARY_OUTLET; });
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} slicedSegments
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function containsEmptyPathMatches(segmentGroup, slicedSegments, routes) {
|
|
return routes.some(function (r) { return emptyPathMatch(segmentGroup, slicedSegments, r); });
|
|
}
|
|
/**
|
|
* @param {?} segmentGroup
|
|
* @param {?} slicedSegments
|
|
* @param {?} r
|
|
* @return {?}
|
|
*/
|
|
function emptyPathMatch(segmentGroup, slicedSegments, r) {
|
|
if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === 'full') {
|
|
return false;
|
|
}
|
|
return r.path === '' && r.redirectTo === undefined;
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function getOutlet$1(route) {
|
|
return route.outlet || PRIMARY_OUTLET;
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function getData(route) {
|
|
return route.data || {};
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function getResolve(route) {
|
|
return route.resolve || {};
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Provides a way to customize when activated routes get reused.
|
|
*
|
|
* \@experimental
|
|
* @abstract
|
|
*/
|
|
var RouteReuseStrategy = /** @class */ (function () {
|
|
function RouteReuseStrategy() {
|
|
}
|
|
return RouteReuseStrategy;
|
|
}());
|
|
/**
|
|
* Does not detach any subtrees. Reuses routes as long as their route config is the same.
|
|
*/
|
|
var DefaultRouteReuseStrategy = /** @class */ (function () {
|
|
function DefaultRouteReuseStrategy() {
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
DefaultRouteReuseStrategy.prototype.shouldDetach = /**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function (route) { return false; };
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} detachedTree
|
|
* @return {?}
|
|
*/
|
|
DefaultRouteReuseStrategy.prototype.store = /**
|
|
* @param {?} route
|
|
* @param {?} detachedTree
|
|
* @return {?}
|
|
*/
|
|
function (route, detachedTree) { };
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
DefaultRouteReuseStrategy.prototype.shouldAttach = /**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function (route) { return false; };
|
|
/**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
DefaultRouteReuseStrategy.prototype.retrieve = /**
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function (route) { return null; };
|
|
/**
|
|
* @param {?} future
|
|
* @param {?} curr
|
|
* @return {?}
|
|
*/
|
|
DefaultRouteReuseStrategy.prototype.shouldReuseRoute = /**
|
|
* @param {?} future
|
|
* @param {?} curr
|
|
* @return {?}
|
|
*/
|
|
function (future, curr) {
|
|
return future.routeConfig === curr.routeConfig;
|
|
};
|
|
return DefaultRouteReuseStrategy;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@docsNotRequired
|
|
* \@experimental
|
|
*/
|
|
var ROUTES = new _angular_core.InjectionToken('ROUTES');
|
|
var RouterConfigLoader = /** @class */ (function () {
|
|
function RouterConfigLoader(loader, compiler, onLoadStartListener, onLoadEndListener) {
|
|
this.loader = loader;
|
|
this.compiler = compiler;
|
|
this.onLoadStartListener = onLoadStartListener;
|
|
this.onLoadEndListener = onLoadEndListener;
|
|
}
|
|
/**
|
|
* @param {?} parentInjector
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
RouterConfigLoader.prototype.load = /**
|
|
* @param {?} parentInjector
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function (parentInjector, route) {
|
|
var _this = this;
|
|
if (this.onLoadStartListener) {
|
|
this.onLoadStartListener(route);
|
|
}
|
|
var /** @type {?} */ moduleFactory$ = this.loadModuleFactory(/** @type {?} */ ((route.loadChildren)));
|
|
return rxjs_operator_map.map.call(moduleFactory$, function (factory) {
|
|
if (_this.onLoadEndListener) {
|
|
_this.onLoadEndListener(route);
|
|
}
|
|
var /** @type {?} */ module = factory.create(parentInjector);
|
|
return new LoadedRouterConfig(flatten(module.injector.get(ROUTES)), module);
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} loadChildren
|
|
* @return {?}
|
|
*/
|
|
RouterConfigLoader.prototype.loadModuleFactory = /**
|
|
* @param {?} loadChildren
|
|
* @return {?}
|
|
*/
|
|
function (loadChildren) {
|
|
var _this = this;
|
|
if (typeof loadChildren === 'string') {
|
|
return rxjs_observable_fromPromise.fromPromise(this.loader.load(loadChildren));
|
|
}
|
|
else {
|
|
return rxjs_operator_mergeMap.mergeMap.call(wrapIntoObservable(loadChildren()), function (t) {
|
|
if (t instanceof _angular_core.NgModuleFactory) {
|
|
return rxjs_observable_of.of(t);
|
|
}
|
|
else {
|
|
return rxjs_observable_fromPromise.fromPromise(_this.compiler.compileModuleAsync(t));
|
|
}
|
|
});
|
|
}
|
|
};
|
|
return RouterConfigLoader;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Provides a way to migrate AngularJS applications to Angular.
|
|
*
|
|
* \@experimental
|
|
* @abstract
|
|
*/
|
|
var UrlHandlingStrategy = /** @class */ (function () {
|
|
function UrlHandlingStrategy() {
|
|
}
|
|
return UrlHandlingStrategy;
|
|
}());
|
|
/**
|
|
* \@experimental
|
|
*/
|
|
var DefaultUrlHandlingStrategy = /** @class */ (function () {
|
|
function DefaultUrlHandlingStrategy() {
|
|
}
|
|
/**
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
DefaultUrlHandlingStrategy.prototype.shouldProcessUrl = /**
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
function (url) { return true; };
|
|
/**
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
DefaultUrlHandlingStrategy.prototype.extract = /**
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
function (url) { return url; };
|
|
/**
|
|
* @param {?} newUrlPart
|
|
* @param {?} wholeUrl
|
|
* @return {?}
|
|
*/
|
|
DefaultUrlHandlingStrategy.prototype.merge = /**
|
|
* @param {?} newUrlPart
|
|
* @param {?} wholeUrl
|
|
* @return {?}
|
|
*/
|
|
function (newUrlPart, wholeUrl) { return newUrlPart; };
|
|
return DefaultUrlHandlingStrategy;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Represents the extra options used during navigation.
|
|
*
|
|
* \@stable
|
|
* @record
|
|
*/
|
|
|
|
/**
|
|
* @param {?} error
|
|
* @return {?}
|
|
*/
|
|
function defaultErrorHandler(error) {
|
|
throw error;
|
|
}
|
|
/**
|
|
* \@internal
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
function defaultRouterHook(snapshot) {
|
|
return /** @type {?} */ (rxjs_observable_of.of(null));
|
|
}
|
|
/**
|
|
* \@whatItDoes Provides the navigation and url manipulation capabilities.
|
|
*
|
|
* See {\@link Routes} for more details and examples.
|
|
*
|
|
* \@ngModule RouterModule
|
|
*
|
|
* \@stable
|
|
*/
|
|
var Router = /** @class */ (function () {
|
|
/**
|
|
* Creates the router service.
|
|
*/
|
|
// TODO: vsavkin make internal after the final is out.
|
|
function Router(rootComponentType, urlSerializer, rootContexts, location, injector, loader, compiler, config) {
|
|
var _this = this;
|
|
this.rootComponentType = rootComponentType;
|
|
this.urlSerializer = urlSerializer;
|
|
this.rootContexts = rootContexts;
|
|
this.location = location;
|
|
this.config = config;
|
|
this.navigations = new rxjs_BehaviorSubject.BehaviorSubject(/** @type {?} */ ((null)));
|
|
this.navigationId = 0;
|
|
this.events = new rxjs_Subject.Subject();
|
|
/**
|
|
* Error handler that is invoked when a navigation errors.
|
|
*
|
|
* See {\@link ErrorHandler} for more information.
|
|
*/
|
|
this.errorHandler = defaultErrorHandler;
|
|
/**
|
|
* Indicates if at least one navigation happened.
|
|
*/
|
|
this.navigated = false;
|
|
this.lastSuccessfulId = -1;
|
|
/**
|
|
* Used by RouterModule. This allows us to
|
|
* pause the navigation either before preactivation or after it.
|
|
* \@internal
|
|
*/
|
|
this.hooks = {
|
|
beforePreactivation: defaultRouterHook,
|
|
afterPreactivation: defaultRouterHook
|
|
};
|
|
/**
|
|
* Extracts and merges URLs. Used for AngularJS to Angular migrations.
|
|
*/
|
|
this.urlHandlingStrategy = new DefaultUrlHandlingStrategy();
|
|
this.routeReuseStrategy = new DefaultRouteReuseStrategy();
|
|
/**
|
|
* Define what the router should do if it receives a navigation request to the current URL.
|
|
* By default, the router will ignore this navigation. However, this prevents features such
|
|
* as a "refresh" button. Use this option to configure the behavior when navigating to the
|
|
* current URL. Default is 'ignore'.
|
|
*/
|
|
this.onSameUrlNavigation = 'ignore';
|
|
/**
|
|
* Defines how the router merges params, data and resolved data from parent to child
|
|
* routes. Available options are:
|
|
*
|
|
* - `'emptyOnly'`, the default, only inherits parent params for path-less or component-less
|
|
* routes.
|
|
* - `'always'`, enables unconditional inheritance of parent params.
|
|
*/
|
|
this.paramsInheritanceStrategy = 'emptyOnly';
|
|
var /** @type {?} */ onLoadStart = function (r) { return _this.triggerEvent(new RouteConfigLoadStart(r)); };
|
|
var /** @type {?} */ onLoadEnd = function (r) { return _this.triggerEvent(new RouteConfigLoadEnd(r)); };
|
|
this.ngModule = injector.get(_angular_core.NgModuleRef);
|
|
this.resetConfig(config);
|
|
this.currentUrlTree = createEmptyUrlTree();
|
|
this.rawUrlTree = this.currentUrlTree;
|
|
this.configLoader = new RouterConfigLoader(loader, compiler, onLoadStart, onLoadEnd);
|
|
this.routerState = createEmptyState(this.currentUrlTree, this.rootComponentType);
|
|
this.processNavigations();
|
|
}
|
|
/**
|
|
* @internal
|
|
* TODO: this should be removed once the constructor of the router made internal
|
|
*/
|
|
/**
|
|
* \@internal
|
|
* TODO: this should be removed once the constructor of the router made internal
|
|
* @param {?} rootComponentType
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.resetRootComponentType = /**
|
|
* \@internal
|
|
* TODO: this should be removed once the constructor of the router made internal
|
|
* @param {?} rootComponentType
|
|
* @return {?}
|
|
*/
|
|
function (rootComponentType) {
|
|
this.rootComponentType = rootComponentType;
|
|
// TODO: vsavkin router 4.0 should make the root component set to null
|
|
// this will simplify the lifecycle of the router.
|
|
this.routerState.root.component = this.rootComponentType;
|
|
};
|
|
/**
|
|
* Sets up the location change listener and performs the initial navigation.
|
|
*/
|
|
/**
|
|
* Sets up the location change listener and performs the initial navigation.
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.initialNavigation = /**
|
|
* Sets up the location change listener and performs the initial navigation.
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.setUpLocationChangeListener();
|
|
if (this.navigationId === 0) {
|
|
this.navigateByUrl(this.location.path(true), { replaceUrl: true });
|
|
}
|
|
};
|
|
/**
|
|
* Sets up the location change listener.
|
|
*/
|
|
/**
|
|
* Sets up the location change listener.
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.setUpLocationChangeListener = /**
|
|
* Sets up the location change listener.
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
// Don't need to use Zone.wrap any more, because zone.js
|
|
// already patch onPopState, so location change callback will
|
|
// run into ngZone
|
|
if (!this.locationSubscription) {
|
|
this.locationSubscription = /** @type {?} */ (this.location.subscribe(function (change) {
|
|
var /** @type {?} */ rawUrlTree = _this.urlSerializer.parse(change['url']);
|
|
var /** @type {?} */ source = change['type'] === 'popstate' ? 'popstate' : 'hashchange';
|
|
var /** @type {?} */ state = change.state && change.state.navigationId ?
|
|
{ navigationId: change.state.navigationId } :
|
|
null;
|
|
setTimeout(function () { _this.scheduleNavigation(rawUrlTree, source, state, { replaceUrl: true }); }, 0);
|
|
}));
|
|
}
|
|
};
|
|
Object.defineProperty(Router.prototype, "url", {
|
|
/** The current url */
|
|
get: /**
|
|
* The current url
|
|
* @return {?}
|
|
*/
|
|
function () { return this.serializeUrl(this.currentUrlTree); },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/** @internal */
|
|
/**
|
|
* \@internal
|
|
* @param {?} e
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.triggerEvent = /**
|
|
* \@internal
|
|
* @param {?} e
|
|
* @return {?}
|
|
*/
|
|
function (e) { (/** @type {?} */ (this.events)).next(e); };
|
|
/**
|
|
* Resets the configuration used for navigation and generating links.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.resetConfig([
|
|
* { path: 'team/:id', component: TeamCmp, children: [
|
|
* { path: 'simple', component: SimpleCmp },
|
|
* { path: 'user/:name', component: UserCmp }
|
|
* ]}
|
|
* ]);
|
|
* ```
|
|
*/
|
|
/**
|
|
* Resets the configuration used for navigation and generating links.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.resetConfig([
|
|
* { path: 'team/:id', component: TeamCmp, children: [
|
|
* { path: 'simple', component: SimpleCmp },
|
|
* { path: 'user/:name', component: UserCmp }
|
|
* ]}
|
|
* ]);
|
|
* ```
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.resetConfig = /**
|
|
* Resets the configuration used for navigation and generating links.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.resetConfig([
|
|
* { path: 'team/:id', component: TeamCmp, children: [
|
|
* { path: 'simple', component: SimpleCmp },
|
|
* { path: 'user/:name', component: UserCmp }
|
|
* ]}
|
|
* ]);
|
|
* ```
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
function (config) {
|
|
validateConfig(config);
|
|
this.config = config;
|
|
this.navigated = false;
|
|
this.lastSuccessfulId = -1;
|
|
};
|
|
/** @docsNotRequired */
|
|
/**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.ngOnDestroy = /**
|
|
* \@docsNotRequired
|
|
* @return {?}
|
|
*/
|
|
function () { this.dispose(); };
|
|
/** Disposes of the router */
|
|
/**
|
|
* Disposes of the router
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.dispose = /**
|
|
* Disposes of the router
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (this.locationSubscription) {
|
|
this.locationSubscription.unsubscribe();
|
|
this.locationSubscription = /** @type {?} */ ((null));
|
|
}
|
|
};
|
|
/**
|
|
* Applies an array of commands to the current url tree and creates a new url tree.
|
|
*
|
|
* When given an activate route, applies the given commands starting from the route.
|
|
* When not given a route, applies the given command starting from the root.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* // create /team/33/user/11
|
|
* router.createUrlTree(['/team', 33, 'user', 11]);
|
|
*
|
|
* // create /team/33;expand=true/user/11
|
|
* router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);
|
|
*
|
|
* // you can collapse static segments like this (this works only with the first passed-in value):
|
|
* router.createUrlTree(['/team/33/user', userId]);
|
|
*
|
|
* // If the first segment can contain slashes, and you do not want the router to split it, you
|
|
* // can do the following:
|
|
*
|
|
* router.createUrlTree([{segmentPath: '/one/two'}]);
|
|
*
|
|
* // create /team/33/(user/11//right:chat)
|
|
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: 'chat'}}]);
|
|
*
|
|
* // remove the right secondary node
|
|
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: null}}]);
|
|
*
|
|
* // assuming the current url is `/team/33/user/11` and the route points to `user/11`
|
|
*
|
|
* // navigate to /team/33/user/11/details
|
|
* router.createUrlTree(['details'], {relativeTo: route});
|
|
*
|
|
* // navigate to /team/33/user/22
|
|
* router.createUrlTree(['../22'], {relativeTo: route});
|
|
*
|
|
* // navigate to /team/44/user/22
|
|
* router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});
|
|
* ```
|
|
*/
|
|
/**
|
|
* Applies an array of commands to the current url tree and creates a new url tree.
|
|
*
|
|
* When given an activate route, applies the given commands starting from the route.
|
|
* When not given a route, applies the given command starting from the root.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* // create /team/33/user/11
|
|
* router.createUrlTree(['/team', 33, 'user', 11]);
|
|
*
|
|
* // create /team/33;expand=true/user/11
|
|
* router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);
|
|
*
|
|
* // you can collapse static segments like this (this works only with the first passed-in value):
|
|
* router.createUrlTree(['/team/33/user', userId]);
|
|
*
|
|
* // If the first segment can contain slashes, and you do not want the router to split it, you
|
|
* // can do the following:
|
|
*
|
|
* router.createUrlTree([{segmentPath: '/one/two'}]);
|
|
*
|
|
* // create /team/33/(user/11//right:chat)
|
|
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: 'chat'}}]);
|
|
*
|
|
* // remove the right secondary node
|
|
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: null}}]);
|
|
*
|
|
* // assuming the current url is `/team/33/user/11` and the route points to `user/11`
|
|
*
|
|
* // navigate to /team/33/user/11/details
|
|
* router.createUrlTree(['details'], {relativeTo: route});
|
|
*
|
|
* // navigate to /team/33/user/22
|
|
* router.createUrlTree(['../22'], {relativeTo: route});
|
|
*
|
|
* // navigate to /team/44/user/22
|
|
* router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});
|
|
* ```
|
|
* @param {?} commands
|
|
* @param {?=} navigationExtras
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.createUrlTree = /**
|
|
* Applies an array of commands to the current url tree and creates a new url tree.
|
|
*
|
|
* When given an activate route, applies the given commands starting from the route.
|
|
* When not given a route, applies the given command starting from the root.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* // create /team/33/user/11
|
|
* router.createUrlTree(['/team', 33, 'user', 11]);
|
|
*
|
|
* // create /team/33;expand=true/user/11
|
|
* router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);
|
|
*
|
|
* // you can collapse static segments like this (this works only with the first passed-in value):
|
|
* router.createUrlTree(['/team/33/user', userId]);
|
|
*
|
|
* // If the first segment can contain slashes, and you do not want the router to split it, you
|
|
* // can do the following:
|
|
*
|
|
* router.createUrlTree([{segmentPath: '/one/two'}]);
|
|
*
|
|
* // create /team/33/(user/11//right:chat)
|
|
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: 'chat'}}]);
|
|
*
|
|
* // remove the right secondary node
|
|
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: null}}]);
|
|
*
|
|
* // assuming the current url is `/team/33/user/11` and the route points to `user/11`
|
|
*
|
|
* // navigate to /team/33/user/11/details
|
|
* router.createUrlTree(['details'], {relativeTo: route});
|
|
*
|
|
* // navigate to /team/33/user/22
|
|
* router.createUrlTree(['../22'], {relativeTo: route});
|
|
*
|
|
* // navigate to /team/44/user/22
|
|
* router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});
|
|
* ```
|
|
* @param {?} commands
|
|
* @param {?=} navigationExtras
|
|
* @return {?}
|
|
*/
|
|
function (commands, navigationExtras) {
|
|
if (navigationExtras === void 0) { navigationExtras = {}; }
|
|
var relativeTo = navigationExtras.relativeTo, queryParams = navigationExtras.queryParams, fragment = navigationExtras.fragment, preserveQueryParams = navigationExtras.preserveQueryParams, queryParamsHandling = navigationExtras.queryParamsHandling, preserveFragment = navigationExtras.preserveFragment;
|
|
if (_angular_core.isDevMode() && preserveQueryParams && /** @type {?} */ (console) && /** @type {?} */ (console.warn)) {
|
|
console.warn('preserveQueryParams is deprecated, use queryParamsHandling instead.');
|
|
}
|
|
var /** @type {?} */ a = relativeTo || this.routerState.root;
|
|
var /** @type {?} */ f = preserveFragment ? this.currentUrlTree.fragment : fragment;
|
|
var /** @type {?} */ q = null;
|
|
if (queryParamsHandling) {
|
|
switch (queryParamsHandling) {
|
|
case 'merge':
|
|
q = __assign({}, this.currentUrlTree.queryParams, queryParams);
|
|
break;
|
|
case 'preserve':
|
|
q = this.currentUrlTree.queryParams;
|
|
break;
|
|
default:
|
|
q = queryParams || null;
|
|
}
|
|
}
|
|
else {
|
|
q = preserveQueryParams ? this.currentUrlTree.queryParams : queryParams || null;
|
|
}
|
|
if (q !== null) {
|
|
q = this.removeEmptyProps(q);
|
|
}
|
|
return createUrlTree(a, this.currentUrlTree, commands, /** @type {?} */ ((q)), /** @type {?} */ ((f)));
|
|
};
|
|
/**
|
|
* Navigate based on the provided url. This navigation is always absolute.
|
|
*
|
|
* Returns a promise that:
|
|
* - resolves to 'true' when navigation succeeds,
|
|
* - resolves to 'false' when navigation fails,
|
|
* - is rejected when an error happens.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.navigateByUrl("/team/33/user/11");
|
|
*
|
|
* // Navigate without updating the URL
|
|
* router.navigateByUrl("/team/33/user/11", { skipLocationChange: true });
|
|
* ```
|
|
*
|
|
* In opposite to `navigate`, `navigateByUrl` takes a whole URL
|
|
* and does not apply any delta to the current one.
|
|
*/
|
|
/**
|
|
* Navigate based on the provided url. This navigation is always absolute.
|
|
*
|
|
* Returns a promise that:
|
|
* - resolves to 'true' when navigation succeeds,
|
|
* - resolves to 'false' when navigation fails,
|
|
* - is rejected when an error happens.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.navigateByUrl("/team/33/user/11");
|
|
*
|
|
* // Navigate without updating the URL
|
|
* router.navigateByUrl("/team/33/user/11", { skipLocationChange: true });
|
|
* ```
|
|
*
|
|
* In opposite to `navigate`, `navigateByUrl` takes a whole URL
|
|
* and does not apply any delta to the current one.
|
|
* @param {?} url
|
|
* @param {?=} extras
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.navigateByUrl = /**
|
|
* Navigate based on the provided url. This navigation is always absolute.
|
|
*
|
|
* Returns a promise that:
|
|
* - resolves to 'true' when navigation succeeds,
|
|
* - resolves to 'false' when navigation fails,
|
|
* - is rejected when an error happens.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.navigateByUrl("/team/33/user/11");
|
|
*
|
|
* // Navigate without updating the URL
|
|
* router.navigateByUrl("/team/33/user/11", { skipLocationChange: true });
|
|
* ```
|
|
*
|
|
* In opposite to `navigate`, `navigateByUrl` takes a whole URL
|
|
* and does not apply any delta to the current one.
|
|
* @param {?} url
|
|
* @param {?=} extras
|
|
* @return {?}
|
|
*/
|
|
function (url, extras) {
|
|
if (extras === void 0) { extras = { skipLocationChange: false }; }
|
|
var /** @type {?} */ urlTree = url instanceof UrlTree ? url : this.parseUrl(url);
|
|
var /** @type {?} */ mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);
|
|
return this.scheduleNavigation(mergedTree, 'imperative', null, extras);
|
|
};
|
|
/**
|
|
* Navigate based on the provided array of commands and a starting point.
|
|
* If no starting route is provided, the navigation is absolute.
|
|
*
|
|
* Returns a promise that:
|
|
* - resolves to 'true' when navigation succeeds,
|
|
* - resolves to 'false' when navigation fails,
|
|
* - is rejected when an error happens.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.navigate(['team', 33, 'user', 11], {relativeTo: route});
|
|
*
|
|
* // Navigate without updating the URL
|
|
* router.navigate(['team', 33, 'user', 11], {relativeTo: route, skipLocationChange: true});
|
|
* ```
|
|
*
|
|
* In opposite to `navigateByUrl`, `navigate` always takes a delta that is applied to the current
|
|
* URL.
|
|
*/
|
|
/**
|
|
* Navigate based on the provided array of commands and a starting point.
|
|
* If no starting route is provided, the navigation is absolute.
|
|
*
|
|
* Returns a promise that:
|
|
* - resolves to 'true' when navigation succeeds,
|
|
* - resolves to 'false' when navigation fails,
|
|
* - is rejected when an error happens.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.navigate(['team', 33, 'user', 11], {relativeTo: route});
|
|
*
|
|
* // Navigate without updating the URL
|
|
* router.navigate(['team', 33, 'user', 11], {relativeTo: route, skipLocationChange: true});
|
|
* ```
|
|
*
|
|
* In opposite to `navigateByUrl`, `navigate` always takes a delta that is applied to the current
|
|
* URL.
|
|
* @param {?} commands
|
|
* @param {?=} extras
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.navigate = /**
|
|
* Navigate based on the provided array of commands and a starting point.
|
|
* If no starting route is provided, the navigation is absolute.
|
|
*
|
|
* Returns a promise that:
|
|
* - resolves to 'true' when navigation succeeds,
|
|
* - resolves to 'false' when navigation fails,
|
|
* - is rejected when an error happens.
|
|
*
|
|
* ### Usage
|
|
*
|
|
* ```
|
|
* router.navigate(['team', 33, 'user', 11], {relativeTo: route});
|
|
*
|
|
* // Navigate without updating the URL
|
|
* router.navigate(['team', 33, 'user', 11], {relativeTo: route, skipLocationChange: true});
|
|
* ```
|
|
*
|
|
* In opposite to `navigateByUrl`, `navigate` always takes a delta that is applied to the current
|
|
* URL.
|
|
* @param {?} commands
|
|
* @param {?=} extras
|
|
* @return {?}
|
|
*/
|
|
function (commands, extras) {
|
|
if (extras === void 0) { extras = { skipLocationChange: false }; }
|
|
validateCommands(commands);
|
|
return this.navigateByUrl(this.createUrlTree(commands, extras), extras);
|
|
};
|
|
/** Serializes a {@link UrlTree} into a string */
|
|
/**
|
|
* Serializes a {\@link UrlTree} into a string
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.serializeUrl = /**
|
|
* Serializes a {\@link UrlTree} into a string
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
function (url) { return this.urlSerializer.serialize(url); };
|
|
/** Parses a string into a {@link UrlTree} */
|
|
/**
|
|
* Parses a string into a {\@link UrlTree}
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.parseUrl = /**
|
|
* Parses a string into a {\@link UrlTree}
|
|
* @param {?} url
|
|
* @return {?}
|
|
*/
|
|
function (url) { return this.urlSerializer.parse(url); };
|
|
/** Returns whether the url is activated */
|
|
/**
|
|
* Returns whether the url is activated
|
|
* @param {?} url
|
|
* @param {?} exact
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.isActive = /**
|
|
* Returns whether the url is activated
|
|
* @param {?} url
|
|
* @param {?} exact
|
|
* @return {?}
|
|
*/
|
|
function (url, exact) {
|
|
if (url instanceof UrlTree) {
|
|
return containsTree(this.currentUrlTree, url, exact);
|
|
}
|
|
var /** @type {?} */ urlTree = this.urlSerializer.parse(url);
|
|
return containsTree(this.currentUrlTree, urlTree, exact);
|
|
};
|
|
/**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.removeEmptyProps = /**
|
|
* @param {?} params
|
|
* @return {?}
|
|
*/
|
|
function (params) {
|
|
return Object.keys(params).reduce(function (result, key) {
|
|
var /** @type {?} */ value = params[key];
|
|
if (value !== null && value !== undefined) {
|
|
result[key] = value;
|
|
}
|
|
return result;
|
|
}, {});
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.processNavigations = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
rxjs_operator_concatMap.concatMap
|
|
.call(this.navigations, function (nav) {
|
|
if (nav) {
|
|
_this.executeScheduledNavigation(nav);
|
|
// a failed navigation should not stop the router from processing
|
|
// further navigations => the catch
|
|
return nav.promise.catch(function () { });
|
|
}
|
|
else {
|
|
return /** @type {?} */ (rxjs_observable_of.of(null));
|
|
}
|
|
})
|
|
.subscribe(function () { });
|
|
};
|
|
/**
|
|
* @param {?} rawUrl
|
|
* @param {?} source
|
|
* @param {?} state
|
|
* @param {?} extras
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.scheduleNavigation = /**
|
|
* @param {?} rawUrl
|
|
* @param {?} source
|
|
* @param {?} state
|
|
* @param {?} extras
|
|
* @return {?}
|
|
*/
|
|
function (rawUrl, source, state, extras) {
|
|
var /** @type {?} */ lastNavigation = this.navigations.value;
|
|
// If the user triggers a navigation imperatively (e.g., by using navigateByUrl),
|
|
// and that navigation results in 'replaceState' that leads to the same URL,
|
|
// we should skip those.
|
|
if (lastNavigation && source !== 'imperative' && lastNavigation.source === 'imperative' &&
|
|
lastNavigation.rawUrl.toString() === rawUrl.toString()) {
|
|
return Promise.resolve(true); // return value is not used
|
|
}
|
|
// Because of a bug in IE and Edge, the location class fires two events (popstate and
|
|
// hashchange) every single time. The second one should be ignored. Otherwise, the URL will
|
|
// flicker. Handles the case when a popstate was emitted first.
|
|
if (lastNavigation && source == 'hashchange' && lastNavigation.source === 'popstate' &&
|
|
lastNavigation.rawUrl.toString() === rawUrl.toString()) {
|
|
return Promise.resolve(true); // return value is not used
|
|
}
|
|
// Because of a bug in IE and Edge, the location class fires two events (popstate and
|
|
// hashchange) every single time. The second one should be ignored. Otherwise, the URL will
|
|
// flicker. Handles the case when a hashchange was emitted first.
|
|
if (lastNavigation && source == 'popstate' && lastNavigation.source === 'hashchange' &&
|
|
lastNavigation.rawUrl.toString() === rawUrl.toString()) {
|
|
return Promise.resolve(true); // return value is not used
|
|
}
|
|
var /** @type {?} */ resolve = null;
|
|
var /** @type {?} */ reject = null;
|
|
var /** @type {?} */ promise = new Promise(function (res, rej) {
|
|
resolve = res;
|
|
reject = rej;
|
|
});
|
|
var /** @type {?} */ id = ++this.navigationId;
|
|
this.navigations.next({ id: id, source: source, state: state, rawUrl: rawUrl, extras: extras, resolve: resolve, reject: reject, promise: promise });
|
|
// Make sure that the error is propagated even though `processNavigations` catch
|
|
// handler does not rethrow
|
|
return promise.catch(function (e) { return Promise.reject(e); });
|
|
};
|
|
/**
|
|
* @param {?} __0
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.executeScheduledNavigation = /**
|
|
* @param {?} __0
|
|
* @return {?}
|
|
*/
|
|
function (_a) {
|
|
var _this = this;
|
|
var id = _a.id, rawUrl = _a.rawUrl, extras = _a.extras, resolve = _a.resolve, reject = _a.reject, source = _a.source, state = _a.state;
|
|
var /** @type {?} */ url = this.urlHandlingStrategy.extract(rawUrl);
|
|
var /** @type {?} */ urlTransition = !this.navigated || url.toString() !== this.currentUrlTree.toString();
|
|
if ((this.onSameUrlNavigation === 'reload' ? true : urlTransition) &&
|
|
this.urlHandlingStrategy.shouldProcessUrl(rawUrl)) {
|
|
(/** @type {?} */ (this.events))
|
|
.next(new NavigationStart(id, this.serializeUrl(url), source, state));
|
|
Promise.resolve()
|
|
.then(function (_) {
|
|
return _this.runNavigate(url, rawUrl, !!extras.skipLocationChange, !!extras.replaceUrl, id, null);
|
|
})
|
|
.then(resolve, reject);
|
|
// we cannot process the current URL, but we could process the previous one =>
|
|
// we need to do some cleanup
|
|
}
|
|
else if (urlTransition && this.rawUrlTree &&
|
|
this.urlHandlingStrategy.shouldProcessUrl(this.rawUrlTree)) {
|
|
(/** @type {?} */ (this.events))
|
|
.next(new NavigationStart(id, this.serializeUrl(url), source, state));
|
|
Promise.resolve()
|
|
.then(function (_) {
|
|
return _this.runNavigate(url, rawUrl, false, false, id, createEmptyState(url, _this.rootComponentType).snapshot);
|
|
})
|
|
.then(resolve, reject);
|
|
}
|
|
else {
|
|
this.rawUrlTree = rawUrl;
|
|
resolve(null);
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} url
|
|
* @param {?} rawUrl
|
|
* @param {?} skipLocationChange
|
|
* @param {?} replaceUrl
|
|
* @param {?} id
|
|
* @param {?} precreatedState
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.runNavigate = /**
|
|
* @param {?} url
|
|
* @param {?} rawUrl
|
|
* @param {?} skipLocationChange
|
|
* @param {?} replaceUrl
|
|
* @param {?} id
|
|
* @param {?} precreatedState
|
|
* @return {?}
|
|
*/
|
|
function (url, rawUrl, skipLocationChange, replaceUrl, id, precreatedState) {
|
|
var _this = this;
|
|
if (id !== this.navigationId) {
|
|
(/** @type {?} */ (this.events))
|
|
.next(new NavigationCancel(id, this.serializeUrl(url), "Navigation ID " + id + " is not equal to the current navigation id " + this.navigationId));
|
|
return Promise.resolve(false);
|
|
}
|
|
return new Promise(function (resolvePromise, rejectPromise) {
|
|
// create an observable of the url and route state snapshot
|
|
// this operation do not result in any side effects
|
|
var /** @type {?} */ urlAndSnapshot$;
|
|
if (!precreatedState) {
|
|
var /** @type {?} */ moduleInjector = _this.ngModule.injector;
|
|
var /** @type {?} */ redirectsApplied$ = applyRedirects(moduleInjector, _this.configLoader, _this.urlSerializer, url, _this.config);
|
|
urlAndSnapshot$ = rxjs_operator_mergeMap.mergeMap.call(redirectsApplied$, function (appliedUrl) {
|
|
return rxjs_operator_map.map.call(recognize(_this.rootComponentType, _this.config, appliedUrl, _this.serializeUrl(appliedUrl), _this.paramsInheritanceStrategy), function (snapshot) {
|
|
(/** @type {?} */ (_this.events))
|
|
.next(new RoutesRecognized(id, _this.serializeUrl(url), _this.serializeUrl(appliedUrl), snapshot));
|
|
return { appliedUrl: appliedUrl, snapshot: snapshot };
|
|
});
|
|
});
|
|
}
|
|
else {
|
|
urlAndSnapshot$ = rxjs_observable_of.of({ appliedUrl: url, snapshot: precreatedState });
|
|
}
|
|
var /** @type {?} */ beforePreactivationDone$ = rxjs_operator_mergeMap.mergeMap.call(urlAndSnapshot$, function (p) {
|
|
return rxjs_operator_map.map.call(_this.hooks.beforePreactivation(p.snapshot), function () { return p; });
|
|
});
|
|
// run preactivation: guards and data resolvers
|
|
var /** @type {?} */ preActivation;
|
|
var /** @type {?} */ preactivationSetup$ = rxjs_operator_map.map.call(beforePreactivationDone$, function (_a) {
|
|
var appliedUrl = _a.appliedUrl, snapshot = _a.snapshot;
|
|
var /** @type {?} */ moduleInjector = _this.ngModule.injector;
|
|
preActivation = new PreActivation(snapshot, _this.routerState.snapshot, moduleInjector, function (evt) { return _this.triggerEvent(evt); });
|
|
preActivation.initialize(_this.rootContexts);
|
|
return { appliedUrl: appliedUrl, snapshot: snapshot };
|
|
});
|
|
var /** @type {?} */ preactivationCheckGuards$ = rxjs_operator_mergeMap.mergeMap.call(preactivationSetup$, function (_a) {
|
|
var appliedUrl = _a.appliedUrl, snapshot = _a.snapshot;
|
|
if (_this.navigationId !== id)
|
|
return rxjs_observable_of.of(false);
|
|
_this.triggerEvent(new GuardsCheckStart(id, _this.serializeUrl(url), appliedUrl, snapshot));
|
|
return rxjs_operator_map.map.call(preActivation.checkGuards(), function (shouldActivate) {
|
|
_this.triggerEvent(new GuardsCheckEnd(id, _this.serializeUrl(url), appliedUrl, snapshot, shouldActivate));
|
|
return { appliedUrl: appliedUrl, snapshot: snapshot, shouldActivate: shouldActivate };
|
|
});
|
|
});
|
|
var /** @type {?} */ preactivationResolveData$ = rxjs_operator_mergeMap.mergeMap.call(preactivationCheckGuards$, function (p) {
|
|
if (_this.navigationId !== id)
|
|
return rxjs_observable_of.of(false);
|
|
if (p.shouldActivate && preActivation.isActivating()) {
|
|
_this.triggerEvent(new ResolveStart(id, _this.serializeUrl(url), p.appliedUrl, p.snapshot));
|
|
return rxjs_operator_map.map.call(preActivation.resolveData(_this.paramsInheritanceStrategy), function () {
|
|
_this.triggerEvent(new ResolveEnd(id, _this.serializeUrl(url), p.appliedUrl, p.snapshot));
|
|
return p;
|
|
});
|
|
}
|
|
else {
|
|
return rxjs_observable_of.of(p);
|
|
}
|
|
});
|
|
var /** @type {?} */ preactivationDone$ = rxjs_operator_mergeMap.mergeMap.call(preactivationResolveData$, function (p) {
|
|
return rxjs_operator_map.map.call(_this.hooks.afterPreactivation(p.snapshot), function () { return p; });
|
|
});
|
|
// create router state
|
|
// this operation has side effects => route state is being affected
|
|
var /** @type {?} */ routerState$ = rxjs_operator_map.map.call(preactivationDone$, function (_a) {
|
|
var appliedUrl = _a.appliedUrl, snapshot = _a.snapshot, shouldActivate = _a.shouldActivate;
|
|
if (shouldActivate) {
|
|
var /** @type {?} */ state = createRouterState(_this.routeReuseStrategy, snapshot, _this.routerState);
|
|
return { appliedUrl: appliedUrl, state: state, shouldActivate: shouldActivate };
|
|
}
|
|
else {
|
|
return { appliedUrl: appliedUrl, state: null, shouldActivate: shouldActivate };
|
|
}
|
|
});
|
|
_this.activateRoutes(routerState$, _this.routerState, _this.currentUrlTree, id, url, rawUrl, skipLocationChange, replaceUrl, resolvePromise, rejectPromise);
|
|
});
|
|
};
|
|
/* @internal */
|
|
/**
|
|
* @param {?} state
|
|
* @param {?} storedState
|
|
* @param {?} storedUrl
|
|
* @param {?} id
|
|
* @param {?} url
|
|
* @param {?} rawUrl
|
|
* @param {?} skipLocationChange
|
|
* @param {?} replaceUrl
|
|
* @param {?} resolvePromise
|
|
* @param {?} rejectPromise
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.activateRoutes = /**
|
|
* @param {?} state
|
|
* @param {?} storedState
|
|
* @param {?} storedUrl
|
|
* @param {?} id
|
|
* @param {?} url
|
|
* @param {?} rawUrl
|
|
* @param {?} skipLocationChange
|
|
* @param {?} replaceUrl
|
|
* @param {?} resolvePromise
|
|
* @param {?} rejectPromise
|
|
* @return {?}
|
|
*/
|
|
function (state, storedState, storedUrl, id, url, rawUrl, skipLocationChange, replaceUrl, resolvePromise, rejectPromise) {
|
|
var _this = this;
|
|
// applied the new router state
|
|
// this operation has side effects
|
|
var /** @type {?} */ navigationIsSuccessful;
|
|
state
|
|
.forEach(function (_a) {
|
|
var appliedUrl = _a.appliedUrl, state = _a.state, shouldActivate = _a.shouldActivate;
|
|
if (!shouldActivate || id !== _this.navigationId) {
|
|
navigationIsSuccessful = false;
|
|
return;
|
|
}
|
|
_this.currentUrlTree = appliedUrl;
|
|
_this.rawUrlTree = _this.urlHandlingStrategy.merge(_this.currentUrlTree, rawUrl);
|
|
(/** @type {?} */ (_this)).routerState = state;
|
|
if (!skipLocationChange) {
|
|
var /** @type {?} */ path = _this.urlSerializer.serialize(_this.rawUrlTree);
|
|
if (_this.location.isCurrentPathEqualTo(path) || replaceUrl) {
|
|
_this.location.replaceState(path, '', { navigationId: id });
|
|
}
|
|
else {
|
|
_this.location.go(path, '', { navigationId: id });
|
|
}
|
|
}
|
|
new ActivateRoutes(_this.routeReuseStrategy, state, storedState, function (evt) { return _this.triggerEvent(evt); })
|
|
.activate(_this.rootContexts);
|
|
navigationIsSuccessful = true;
|
|
})
|
|
.then(function () {
|
|
if (navigationIsSuccessful) {
|
|
_this.navigated = true;
|
|
_this.lastSuccessfulId = id;
|
|
(/** @type {?} */ (_this.events))
|
|
.next(new NavigationEnd(id, _this.serializeUrl(url), _this.serializeUrl(_this.currentUrlTree)));
|
|
resolvePromise(true);
|
|
}
|
|
else {
|
|
_this.resetUrlToCurrentUrlTree();
|
|
(/** @type {?} */ (_this.events))
|
|
.next(new NavigationCancel(id, _this.serializeUrl(url), ''));
|
|
resolvePromise(false);
|
|
}
|
|
}, function (e) {
|
|
if (isNavigationCancelingError(e)) {
|
|
_this.navigated = true;
|
|
_this.resetStateAndUrl(storedState, storedUrl, rawUrl);
|
|
(/** @type {?} */ (_this.events))
|
|
.next(new NavigationCancel(id, _this.serializeUrl(url), e.message));
|
|
resolvePromise(false);
|
|
}
|
|
else {
|
|
_this.resetStateAndUrl(storedState, storedUrl, rawUrl);
|
|
(/** @type {?} */ (_this.events))
|
|
.next(new NavigationError(id, _this.serializeUrl(url), e));
|
|
try {
|
|
resolvePromise(_this.errorHandler(e));
|
|
}
|
|
catch (/** @type {?} */ ee) {
|
|
rejectPromise(ee);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} storedState
|
|
* @param {?} storedUrl
|
|
* @param {?} rawUrl
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.resetStateAndUrl = /**
|
|
* @param {?} storedState
|
|
* @param {?} storedUrl
|
|
* @param {?} rawUrl
|
|
* @return {?}
|
|
*/
|
|
function (storedState, storedUrl, rawUrl) {
|
|
(/** @type {?} */ (this)).routerState = storedState;
|
|
this.currentUrlTree = storedUrl;
|
|
this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, rawUrl);
|
|
this.resetUrlToCurrentUrlTree();
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
Router.prototype.resetUrlToCurrentUrlTree = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), '', { navigationId: this.lastSuccessfulId });
|
|
};
|
|
return Router;
|
|
}());
|
|
var ActivateRoutes = /** @class */ (function () {
|
|
function ActivateRoutes(routeReuseStrategy, futureState, currState, forwardEvent) {
|
|
this.routeReuseStrategy = routeReuseStrategy;
|
|
this.futureState = futureState;
|
|
this.currState = currState;
|
|
this.forwardEvent = forwardEvent;
|
|
}
|
|
/**
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.activate = /**
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
function (parentContexts) {
|
|
var /** @type {?} */ futureRoot = this.futureState._root;
|
|
var /** @type {?} */ currRoot = this.currState ? this.currState._root : null;
|
|
this.deactivateChildRoutes(futureRoot, currRoot, parentContexts);
|
|
advanceActivatedRoute(this.futureState.root);
|
|
this.activateChildRoutes(futureRoot, currRoot, parentContexts);
|
|
};
|
|
/**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} contexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.deactivateChildRoutes = /**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} contexts
|
|
* @return {?}
|
|
*/
|
|
function (futureNode, currNode, contexts) {
|
|
var _this = this;
|
|
var /** @type {?} */ children = nodeChildrenAsMap(currNode);
|
|
// Recurse on the routes active in the future state to de-activate deeper children
|
|
futureNode.children.forEach(function (futureChild) {
|
|
var /** @type {?} */ childOutletName = futureChild.value.outlet;
|
|
_this.deactivateRoutes(futureChild, children[childOutletName], contexts);
|
|
delete children[childOutletName];
|
|
});
|
|
// De-activate the routes that will not be re-used
|
|
forEach(children, function (v, childName) {
|
|
_this.deactivateRouteAndItsChildren(v, contexts);
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} parentContext
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.deactivateRoutes = /**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} parentContext
|
|
* @return {?}
|
|
*/
|
|
function (futureNode, currNode, parentContext) {
|
|
var /** @type {?} */ future = futureNode.value;
|
|
var /** @type {?} */ curr = currNode ? currNode.value : null;
|
|
if (future === curr) {
|
|
// Reusing the node, check to see if the children need to be de-activated
|
|
if (future.component) {
|
|
// If we have a normal route, we need to go through an outlet.
|
|
var /** @type {?} */ context = parentContext.getContext(future.outlet);
|
|
if (context) {
|
|
this.deactivateChildRoutes(futureNode, currNode, context.children);
|
|
}
|
|
}
|
|
else {
|
|
// if we have a componentless route, we recurse but keep the same outlet map.
|
|
this.deactivateChildRoutes(futureNode, currNode, parentContext);
|
|
}
|
|
}
|
|
else {
|
|
if (curr) {
|
|
// Deactivate the current route which will not be re-used
|
|
this.deactivateRouteAndItsChildren(currNode, parentContext);
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.deactivateRouteAndItsChildren = /**
|
|
* @param {?} route
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
function (route, parentContexts) {
|
|
if (this.routeReuseStrategy.shouldDetach(route.value.snapshot)) {
|
|
this.detachAndStoreRouteSubtree(route, parentContexts);
|
|
}
|
|
else {
|
|
this.deactivateRouteAndOutlet(route, parentContexts);
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.detachAndStoreRouteSubtree = /**
|
|
* @param {?} route
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
function (route, parentContexts) {
|
|
var /** @type {?} */ context = parentContexts.getContext(route.value.outlet);
|
|
if (context && context.outlet) {
|
|
var /** @type {?} */ componentRef = context.outlet.detach();
|
|
var /** @type {?} */ contexts = context.children.onOutletDeactivated();
|
|
this.routeReuseStrategy.store(route.value.snapshot, { componentRef: componentRef, route: route, contexts: contexts });
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.deactivateRouteAndOutlet = /**
|
|
* @param {?} route
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
function (route, parentContexts) {
|
|
var _this = this;
|
|
var /** @type {?} */ context = parentContexts.getContext(route.value.outlet);
|
|
if (context) {
|
|
var /** @type {?} */ children = nodeChildrenAsMap(route);
|
|
var /** @type {?} */ contexts_1 = route.value.component ? context.children : parentContexts;
|
|
forEach(children, function (v, k) { return _this.deactivateRouteAndItsChildren(v, contexts_1); });
|
|
if (context.outlet) {
|
|
// Destroy the component
|
|
context.outlet.deactivate();
|
|
// Destroy the contexts for all the outlets that were in the component
|
|
context.children.onOutletDeactivated();
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} contexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.activateChildRoutes = /**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} contexts
|
|
* @return {?}
|
|
*/
|
|
function (futureNode, currNode, contexts) {
|
|
var _this = this;
|
|
var /** @type {?} */ children = nodeChildrenAsMap(currNode);
|
|
futureNode.children.forEach(function (c) {
|
|
_this.activateRoutes(c, children[c.value.outlet], contexts);
|
|
_this.forwardEvent(new ActivationEnd(c.value.snapshot));
|
|
});
|
|
if (futureNode.children.length) {
|
|
this.forwardEvent(new ChildActivationEnd(futureNode.value.snapshot));
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
ActivateRoutes.prototype.activateRoutes = /**
|
|
* @param {?} futureNode
|
|
* @param {?} currNode
|
|
* @param {?} parentContexts
|
|
* @return {?}
|
|
*/
|
|
function (futureNode, currNode, parentContexts) {
|
|
var /** @type {?} */ future = futureNode.value;
|
|
var /** @type {?} */ curr = currNode ? currNode.value : null;
|
|
advanceActivatedRoute(future);
|
|
// reusing the node
|
|
if (future === curr) {
|
|
if (future.component) {
|
|
// If we have a normal route, we need to go through an outlet.
|
|
var /** @type {?} */ context = parentContexts.getOrCreateContext(future.outlet);
|
|
this.activateChildRoutes(futureNode, currNode, context.children);
|
|
}
|
|
else {
|
|
// if we have a componentless route, we recurse but keep the same outlet map.
|
|
this.activateChildRoutes(futureNode, currNode, parentContexts);
|
|
}
|
|
}
|
|
else {
|
|
if (future.component) {
|
|
// if we have a normal route, we need to place the component into the outlet and recurse.
|
|
var /** @type {?} */ context = parentContexts.getOrCreateContext(future.outlet);
|
|
if (this.routeReuseStrategy.shouldAttach(future.snapshot)) {
|
|
var /** @type {?} */ stored = (/** @type {?} */ (this.routeReuseStrategy.retrieve(future.snapshot)));
|
|
this.routeReuseStrategy.store(future.snapshot, null);
|
|
context.children.onOutletReAttached(stored.contexts);
|
|
context.attachRef = stored.componentRef;
|
|
context.route = stored.route.value;
|
|
if (context.outlet) {
|
|
// Attach right away when the outlet has already been instantiated
|
|
// Otherwise attach from `RouterOutlet.ngOnInit` when it is instantiated
|
|
context.outlet.attach(stored.componentRef, stored.route.value);
|
|
}
|
|
advanceActivatedRouteNodeAndItsChildren(stored.route);
|
|
}
|
|
else {
|
|
var /** @type {?} */ config = parentLoadedConfig(future.snapshot);
|
|
var /** @type {?} */ cmpFactoryResolver = config ? config.module.componentFactoryResolver : null;
|
|
context.route = future;
|
|
context.resolver = cmpFactoryResolver;
|
|
if (context.outlet) {
|
|
// Activate the outlet when it has already been instantiated
|
|
// Otherwise it will get activated from its `ngOnInit` when instantiated
|
|
context.outlet.activateWith(future, cmpFactoryResolver);
|
|
}
|
|
this.activateChildRoutes(futureNode, null, context.children);
|
|
}
|
|
}
|
|
else {
|
|
// if we have a componentless route, we recurse but keep the same outlet map.
|
|
this.activateChildRoutes(futureNode, null, parentContexts);
|
|
}
|
|
}
|
|
};
|
|
return ActivateRoutes;
|
|
}());
|
|
/**
|
|
* @param {?} node
|
|
* @return {?}
|
|
*/
|
|
function advanceActivatedRouteNodeAndItsChildren(node) {
|
|
advanceActivatedRoute(node.value);
|
|
node.children.forEach(advanceActivatedRouteNodeAndItsChildren);
|
|
}
|
|
/**
|
|
* @param {?} snapshot
|
|
* @return {?}
|
|
*/
|
|
function parentLoadedConfig(snapshot) {
|
|
for (var /** @type {?} */ s = snapshot.parent; s; s = s.parent) {
|
|
var /** @type {?} */ route = s.routeConfig;
|
|
if (route && route._loadedConfig)
|
|
return route._loadedConfig;
|
|
if (route && route.component)
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function validateCommands(commands) {
|
|
for (var /** @type {?} */ i = 0; i < commands.length; i++) {
|
|
var /** @type {?} */ cmd = commands[i];
|
|
if (cmd == null) {
|
|
throw new Error("The requested path contains " + cmd + " segment at index " + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Lets you link to specific parts of your app.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* Consider the following route configuration:
|
|
* `[{ path: 'user/:name', component: UserCmp }]`
|
|
*
|
|
* When linking to this `user/:name` route, you can write:
|
|
* `<a routerLink='/user/bob'>link to user component</a>`
|
|
*
|
|
* \@description
|
|
*
|
|
* The RouterLink directives let you link to specific parts of your app.
|
|
*
|
|
* When the link is static, you can use the directive as follows:
|
|
* `<a routerLink="/user/bob">link to user component</a>`
|
|
*
|
|
* If you use dynamic values to generate the link, you can pass an array of path
|
|
* segments, followed by the params for each segment.
|
|
*
|
|
* For instance `['/team', teamId, 'user', userName, {details: true}]`
|
|
* means that we want to generate a link to `/team/11/user/bob;details=true`.
|
|
*
|
|
* Multiple static segments can be merged into one
|
|
* (e.g., `['/team/11/user', userName, {details: true}]`).
|
|
*
|
|
* The first segment name can be prepended with `/`, `./`, or `../`:
|
|
* * If the first segment begins with `/`, the router will look up the route from the root of the
|
|
* app.
|
|
* * If the first segment begins with `./`, or doesn't begin with a slash, the router will
|
|
* instead look in the children of the current activated route.
|
|
* * And if the first segment begins with `../`, the router will go up one level.
|
|
*
|
|
* You can set query params and fragment as follows:
|
|
*
|
|
* ```
|
|
* <a [routerLink]="['/user/bob']" [queryParams]="{debug: true}" fragment="education">
|
|
* link to user component
|
|
* </a>
|
|
* ```
|
|
* RouterLink will use these to generate this link: `/user/bob#education?debug=true`.
|
|
*
|
|
* (Deprecated in v4.0.0 use `queryParamsHandling` instead) You can also tell the
|
|
* directive to preserve the current query params and fragment:
|
|
*
|
|
* ```
|
|
* <a [routerLink]="['/user/bob']" preserveQueryParams preserveFragment>
|
|
* link to user component
|
|
* </a>
|
|
* ```
|
|
*
|
|
* You can tell the directive to how to handle queryParams, available options are:
|
|
* - `'merge'`: merge the queryParams into the current queryParams
|
|
* - `'preserve'`: preserve the current queryParams
|
|
* - default/`''`: use the queryParams only
|
|
*
|
|
* Same options for {\@link NavigationExtras#queryParamsHandling
|
|
* NavigationExtras#queryParamsHandling}.
|
|
*
|
|
* ```
|
|
* <a [routerLink]="['/user/bob']" [queryParams]="{debug: true}" queryParamsHandling="merge">
|
|
* link to user component
|
|
* </a>
|
|
* ```
|
|
*
|
|
* The router link directive always treats the provided input as a delta to the current url.
|
|
*
|
|
* For instance, if the current url is `/user/(box//aux:team)`.
|
|
*
|
|
* Then the following link `<a [routerLink]="['/user/jim']">Jim</a>` will generate the link
|
|
* `/user/(jim//aux:team)`.
|
|
*
|
|
* See {\@link Router#createUrlTree createUrlTree} for more information.
|
|
*
|
|
* \@ngModule RouterModule
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterLink = /** @class */ (function () {
|
|
function RouterLink(router, route, tabIndex, renderer, el) {
|
|
this.router = router;
|
|
this.route = route;
|
|
this.commands = [];
|
|
if (tabIndex == null) {
|
|
renderer.setAttribute(el.nativeElement, 'tabindex', '0');
|
|
}
|
|
}
|
|
Object.defineProperty(RouterLink.prototype, "routerLink", {
|
|
set: /**
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function (commands) {
|
|
if (commands != null) {
|
|
this.commands = Array.isArray(commands) ? commands : [commands];
|
|
}
|
|
else {
|
|
this.commands = [];
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(RouterLink.prototype, "preserveQueryParams", {
|
|
set: /**
|
|
* @deprecated 4.0.0 use `queryParamsHandling` instead.
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
function (value) {
|
|
if (_angular_core.isDevMode() && /** @type {?} */ (console) && /** @type {?} */ (console.warn)) {
|
|
console.warn('preserveQueryParams is deprecated!, use queryParamsHandling instead.');
|
|
}
|
|
this.preserve = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLink.prototype.onClick = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ extras = {
|
|
skipLocationChange: attrBoolValue(this.skipLocationChange),
|
|
replaceUrl: attrBoolValue(this.replaceUrl),
|
|
};
|
|
this.router.navigateByUrl(this.urlTree, extras);
|
|
return true;
|
|
};
|
|
Object.defineProperty(RouterLink.prototype, "urlTree", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.router.createUrlTree(this.commands, {
|
|
relativeTo: this.route,
|
|
queryParams: this.queryParams,
|
|
fragment: this.fragment,
|
|
preserveQueryParams: attrBoolValue(this.preserve),
|
|
queryParamsHandling: this.queryParamsHandling,
|
|
preserveFragment: attrBoolValue(this.preserveFragment),
|
|
});
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
RouterLink.decorators = [
|
|
{ type: _angular_core.Directive, args: [{ selector: ':not(a)[routerLink]' },] },
|
|
];
|
|
/** @nocollapse */
|
|
RouterLink.ctorParameters = function () { return [
|
|
{ type: Router, },
|
|
{ type: ActivatedRoute, },
|
|
{ type: undefined, decorators: [{ type: _angular_core.Attribute, args: ['tabindex',] },] },
|
|
{ type: _angular_core.Renderer2, },
|
|
{ type: _angular_core.ElementRef, },
|
|
]; };
|
|
RouterLink.propDecorators = {
|
|
"queryParams": [{ type: _angular_core.Input },],
|
|
"fragment": [{ type: _angular_core.Input },],
|
|
"queryParamsHandling": [{ type: _angular_core.Input },],
|
|
"preserveFragment": [{ type: _angular_core.Input },],
|
|
"skipLocationChange": [{ type: _angular_core.Input },],
|
|
"replaceUrl": [{ type: _angular_core.Input },],
|
|
"routerLink": [{ type: _angular_core.Input },],
|
|
"preserveQueryParams": [{ type: _angular_core.Input },],
|
|
"onClick": [{ type: _angular_core.HostListener, args: ['click',] },],
|
|
};
|
|
return RouterLink;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Lets you link to specific parts of your app.
|
|
*
|
|
* See {\@link RouterLink} for more information.
|
|
*
|
|
* \@ngModule RouterModule
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterLinkWithHref = /** @class */ (function () {
|
|
function RouterLinkWithHref(router, route, locationStrategy) {
|
|
var _this = this;
|
|
this.router = router;
|
|
this.route = route;
|
|
this.locationStrategy = locationStrategy;
|
|
this.commands = [];
|
|
this.subscription = router.events.subscribe(function (s) {
|
|
if (s instanceof NavigationEnd) {
|
|
_this.updateTargetUrlAndHref();
|
|
}
|
|
});
|
|
}
|
|
Object.defineProperty(RouterLinkWithHref.prototype, "routerLink", {
|
|
set: /**
|
|
* @param {?} commands
|
|
* @return {?}
|
|
*/
|
|
function (commands) {
|
|
if (commands != null) {
|
|
this.commands = Array.isArray(commands) ? commands : [commands];
|
|
}
|
|
else {
|
|
this.commands = [];
|
|
}
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(RouterLinkWithHref.prototype, "preserveQueryParams", {
|
|
set: /**
|
|
* @param {?} value
|
|
* @return {?}
|
|
*/
|
|
function (value) {
|
|
if (_angular_core.isDevMode() && /** @type {?} */ (console) && /** @type {?} */ (console.warn)) {
|
|
console.warn('preserveQueryParams is deprecated, use queryParamsHandling instead.');
|
|
}
|
|
this.preserve = value;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
RouterLinkWithHref.prototype.ngOnChanges = /**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
function (changes) { this.updateTargetUrlAndHref(); };
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLinkWithHref.prototype.ngOnDestroy = /**
|
|
* @return {?}
|
|
*/
|
|
function () { this.subscription.unsubscribe(); };
|
|
/**
|
|
* @param {?} button
|
|
* @param {?} ctrlKey
|
|
* @param {?} metaKey
|
|
* @param {?} shiftKey
|
|
* @return {?}
|
|
*/
|
|
RouterLinkWithHref.prototype.onClick = /**
|
|
* @param {?} button
|
|
* @param {?} ctrlKey
|
|
* @param {?} metaKey
|
|
* @param {?} shiftKey
|
|
* @return {?}
|
|
*/
|
|
function (button, ctrlKey, metaKey, shiftKey) {
|
|
if (button !== 0 || ctrlKey || metaKey || shiftKey) {
|
|
return true;
|
|
}
|
|
if (typeof this.target === 'string' && this.target != '_self') {
|
|
return true;
|
|
}
|
|
var /** @type {?} */ extras = {
|
|
skipLocationChange: attrBoolValue(this.skipLocationChange),
|
|
replaceUrl: attrBoolValue(this.replaceUrl),
|
|
};
|
|
this.router.navigateByUrl(this.urlTree, extras);
|
|
return false;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLinkWithHref.prototype.updateTargetUrlAndHref = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.href = this.locationStrategy.prepareExternalUrl(this.router.serializeUrl(this.urlTree));
|
|
};
|
|
Object.defineProperty(RouterLinkWithHref.prototype, "urlTree", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.router.createUrlTree(this.commands, {
|
|
relativeTo: this.route,
|
|
queryParams: this.queryParams,
|
|
fragment: this.fragment,
|
|
preserveQueryParams: attrBoolValue(this.preserve),
|
|
queryParamsHandling: this.queryParamsHandling,
|
|
preserveFragment: attrBoolValue(this.preserveFragment),
|
|
});
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
RouterLinkWithHref.decorators = [
|
|
{ type: _angular_core.Directive, args: [{ selector: 'a[routerLink]' },] },
|
|
];
|
|
/** @nocollapse */
|
|
RouterLinkWithHref.ctorParameters = function () { return [
|
|
{ type: Router, },
|
|
{ type: ActivatedRoute, },
|
|
{ type: _angular_common.LocationStrategy, },
|
|
]; };
|
|
RouterLinkWithHref.propDecorators = {
|
|
"target": [{ type: _angular_core.HostBinding, args: ['attr.target',] }, { type: _angular_core.Input },],
|
|
"queryParams": [{ type: _angular_core.Input },],
|
|
"fragment": [{ type: _angular_core.Input },],
|
|
"queryParamsHandling": [{ type: _angular_core.Input },],
|
|
"preserveFragment": [{ type: _angular_core.Input },],
|
|
"skipLocationChange": [{ type: _angular_core.Input },],
|
|
"replaceUrl": [{ type: _angular_core.Input },],
|
|
"href": [{ type: _angular_core.HostBinding },],
|
|
"routerLink": [{ type: _angular_core.Input },],
|
|
"preserveQueryParams": [{ type: _angular_core.Input },],
|
|
"onClick": [{ type: _angular_core.HostListener, args: ['click', ['$event.button', '$event.ctrlKey', '$event.metaKey', '$event.shiftKey'],] },],
|
|
};
|
|
return RouterLinkWithHref;
|
|
}());
|
|
/**
|
|
* @param {?} s
|
|
* @return {?}
|
|
*/
|
|
function attrBoolValue(s) {
|
|
return s === '' || !!s;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Lets you add a CSS class to an element when the link's route becomes active.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* <a routerLink="/user/bob" routerLinkActive="active-link">Bob</a>
|
|
* ```
|
|
*
|
|
* \@description
|
|
*
|
|
* The RouterLinkActive directive lets you add a CSS class to an element when the link's route
|
|
* becomes active.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* <a routerLink="/user/bob" routerLinkActive="active-link">Bob</a>
|
|
* ```
|
|
*
|
|
* When the url is either '/user' or '/user/bob', the active-link class will
|
|
* be added to the `a` tag. If the url changes, the class will be removed.
|
|
*
|
|
* You can set more than one class, as follows:
|
|
*
|
|
* ```
|
|
* <a routerLink="/user/bob" routerLinkActive="class1 class2">Bob</a>
|
|
* <a routerLink="/user/bob" [routerLinkActive]="['class1', 'class2']">Bob</a>
|
|
* ```
|
|
*
|
|
* You can configure RouterLinkActive by passing `exact: true`. This will add the classes
|
|
* only when the url matches the link exactly.
|
|
*
|
|
* ```
|
|
* <a routerLink="/user/bob" routerLinkActive="active-link" [routerLinkActiveOptions]="{exact:
|
|
* true}">Bob</a>
|
|
* ```
|
|
*
|
|
* You can assign the RouterLinkActive instance to a template variable and directly check
|
|
* the `isActive` status.
|
|
* ```
|
|
* <a routerLink="/user/bob" routerLinkActive #rla="routerLinkActive">
|
|
* Bob {{ rla.isActive ? '(already open)' : ''}}
|
|
* </a>
|
|
* ```
|
|
*
|
|
* Finally, you can apply the RouterLinkActive directive to an ancestor of a RouterLink.
|
|
*
|
|
* ```
|
|
* <div routerLinkActive="active-link" [routerLinkActiveOptions]="{exact: true}">
|
|
* <a routerLink="/user/jim">Jim</a>
|
|
* <a routerLink="/user/bob">Bob</a>
|
|
* </div>
|
|
* ```
|
|
*
|
|
* This will set the active-link class on the div tag if the url is either '/user/jim' or
|
|
* '/user/bob'.
|
|
*
|
|
* \@ngModule RouterModule
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterLinkActive = /** @class */ (function () {
|
|
function RouterLinkActive(router, element, renderer, cdr) {
|
|
var _this = this;
|
|
this.router = router;
|
|
this.element = element;
|
|
this.renderer = renderer;
|
|
this.cdr = cdr;
|
|
this.classes = [];
|
|
this.isActive = false;
|
|
this.routerLinkActiveOptions = { exact: false };
|
|
this.subscription = router.events.subscribe(function (s) {
|
|
if (s instanceof NavigationEnd) {
|
|
_this.update();
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLinkActive.prototype.ngAfterContentInit = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
this.links.changes.subscribe(function (_) { return _this.update(); });
|
|
this.linksWithHrefs.changes.subscribe(function (_) { return _this.update(); });
|
|
this.update();
|
|
};
|
|
Object.defineProperty(RouterLinkActive.prototype, "routerLinkActive", {
|
|
set: /**
|
|
* @param {?} data
|
|
* @return {?}
|
|
*/
|
|
function (data) {
|
|
var /** @type {?} */ classes = Array.isArray(data) ? data : data.split(' ');
|
|
this.classes = classes.filter(function (c) { return !!c; });
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
RouterLinkActive.prototype.ngOnChanges = /**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
function (changes) { this.update(); };
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLinkActive.prototype.ngOnDestroy = /**
|
|
* @return {?}
|
|
*/
|
|
function () { this.subscription.unsubscribe(); };
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLinkActive.prototype.update = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
if (!this.links || !this.linksWithHrefs || !this.router.navigated)
|
|
return;
|
|
Promise.resolve().then(function () {
|
|
var /** @type {?} */ hasActiveLinks = _this.hasActiveLinks();
|
|
if (_this.isActive !== hasActiveLinks) {
|
|
(/** @type {?} */ (_this)).isActive = hasActiveLinks;
|
|
_this.classes.forEach(function (c) {
|
|
if (hasActiveLinks) {
|
|
_this.renderer.addClass(_this.element.nativeElement, c);
|
|
}
|
|
else {
|
|
_this.renderer.removeClass(_this.element.nativeElement, c);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} router
|
|
* @return {?}
|
|
*/
|
|
RouterLinkActive.prototype.isLinkActive = /**
|
|
* @param {?} router
|
|
* @return {?}
|
|
*/
|
|
function (router) {
|
|
var _this = this;
|
|
return function (link) {
|
|
return router.isActive(link.urlTree, _this.routerLinkActiveOptions.exact);
|
|
};
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterLinkActive.prototype.hasActiveLinks = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.links.some(this.isLinkActive(this.router)) ||
|
|
this.linksWithHrefs.some(this.isLinkActive(this.router));
|
|
};
|
|
RouterLinkActive.decorators = [
|
|
{ type: _angular_core.Directive, args: [{
|
|
selector: '[routerLinkActive]',
|
|
exportAs: 'routerLinkActive',
|
|
},] },
|
|
];
|
|
/** @nocollapse */
|
|
RouterLinkActive.ctorParameters = function () { return [
|
|
{ type: Router, },
|
|
{ type: _angular_core.ElementRef, },
|
|
{ type: _angular_core.Renderer2, },
|
|
{ type: _angular_core.ChangeDetectorRef, },
|
|
]; };
|
|
RouterLinkActive.propDecorators = {
|
|
"links": [{ type: _angular_core.ContentChildren, args: [RouterLink, { descendants: true },] },],
|
|
"linksWithHrefs": [{ type: _angular_core.ContentChildren, args: [RouterLinkWithHref, { descendants: true },] },],
|
|
"routerLinkActiveOptions": [{ type: _angular_core.Input },],
|
|
"routerLinkActive": [{ type: _angular_core.Input },],
|
|
};
|
|
return RouterLinkActive;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* Store contextual information about a {\@link RouterOutlet}
|
|
*
|
|
* \@stable
|
|
*/
|
|
var OutletContext = /** @class */ (function () {
|
|
function OutletContext() {
|
|
this.outlet = null;
|
|
this.route = null;
|
|
this.resolver = null;
|
|
this.children = new ChildrenOutletContexts();
|
|
this.attachRef = null;
|
|
}
|
|
return OutletContext;
|
|
}());
|
|
/**
|
|
* Store contextual information about the children (= nested) {\@link RouterOutlet}
|
|
*
|
|
* \@stable
|
|
*/
|
|
var ChildrenOutletContexts = /** @class */ (function () {
|
|
function ChildrenOutletContexts() {
|
|
this.contexts = new Map();
|
|
}
|
|
/** Called when a `RouterOutlet` directive is instantiated */
|
|
/**
|
|
* Called when a `RouterOutlet` directive is instantiated
|
|
* @param {?} childName
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
ChildrenOutletContexts.prototype.onChildOutletCreated = /**
|
|
* Called when a `RouterOutlet` directive is instantiated
|
|
* @param {?} childName
|
|
* @param {?} outlet
|
|
* @return {?}
|
|
*/
|
|
function (childName, outlet) {
|
|
var /** @type {?} */ context = this.getOrCreateContext(childName);
|
|
context.outlet = outlet;
|
|
this.contexts.set(childName, context);
|
|
};
|
|
/**
|
|
* Called when a `RouterOutlet` directive is destroyed.
|
|
* We need to keep the context as the outlet could be destroyed inside a NgIf and might be
|
|
* re-created later.
|
|
*/
|
|
/**
|
|
* Called when a `RouterOutlet` directive is destroyed.
|
|
* We need to keep the context as the outlet could be destroyed inside a NgIf and might be
|
|
* re-created later.
|
|
* @param {?} childName
|
|
* @return {?}
|
|
*/
|
|
ChildrenOutletContexts.prototype.onChildOutletDestroyed = /**
|
|
* Called when a `RouterOutlet` directive is destroyed.
|
|
* We need to keep the context as the outlet could be destroyed inside a NgIf and might be
|
|
* re-created later.
|
|
* @param {?} childName
|
|
* @return {?}
|
|
*/
|
|
function (childName) {
|
|
var /** @type {?} */ context = this.getContext(childName);
|
|
if (context) {
|
|
context.outlet = null;
|
|
}
|
|
};
|
|
/**
|
|
* Called when the corresponding route is deactivated during navigation.
|
|
* Because the component get destroyed, all children outlet are destroyed.
|
|
*/
|
|
/**
|
|
* Called when the corresponding route is deactivated during navigation.
|
|
* Because the component get destroyed, all children outlet are destroyed.
|
|
* @return {?}
|
|
*/
|
|
ChildrenOutletContexts.prototype.onOutletDeactivated = /**
|
|
* Called when the corresponding route is deactivated during navigation.
|
|
* Because the component get destroyed, all children outlet are destroyed.
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ contexts = this.contexts;
|
|
this.contexts = new Map();
|
|
return contexts;
|
|
};
|
|
/**
|
|
* @param {?} contexts
|
|
* @return {?}
|
|
*/
|
|
ChildrenOutletContexts.prototype.onOutletReAttached = /**
|
|
* @param {?} contexts
|
|
* @return {?}
|
|
*/
|
|
function (contexts) { this.contexts = contexts; };
|
|
/**
|
|
* @param {?} childName
|
|
* @return {?}
|
|
*/
|
|
ChildrenOutletContexts.prototype.getOrCreateContext = /**
|
|
* @param {?} childName
|
|
* @return {?}
|
|
*/
|
|
function (childName) {
|
|
var /** @type {?} */ context = this.getContext(childName);
|
|
if (!context) {
|
|
context = new OutletContext();
|
|
this.contexts.set(childName, context);
|
|
}
|
|
return context;
|
|
};
|
|
/**
|
|
* @param {?} childName
|
|
* @return {?}
|
|
*/
|
|
ChildrenOutletContexts.prototype.getContext = /**
|
|
* @param {?} childName
|
|
* @return {?}
|
|
*/
|
|
function (childName) { return this.contexts.get(childName) || null; };
|
|
return ChildrenOutletContexts;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Acts as a placeholder that Angular dynamically fills based on the current router
|
|
* state.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* <router-outlet></router-outlet>
|
|
* <router-outlet name='left'></router-outlet>
|
|
* <router-outlet name='right'></router-outlet>
|
|
* ```
|
|
*
|
|
* A router outlet will emit an activate event any time a new component is being instantiated,
|
|
* and a deactivate event when it is being destroyed.
|
|
*
|
|
* ```
|
|
* <router-outlet
|
|
* (activate)='onActivate($event)'
|
|
* (deactivate)='onDeactivate($event)'></router-outlet>
|
|
* ```
|
|
* \@ngModule RouterModule
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterOutlet = /** @class */ (function () {
|
|
function RouterOutlet(parentContexts, location, resolver, name, changeDetector) {
|
|
this.parentContexts = parentContexts;
|
|
this.location = location;
|
|
this.resolver = resolver;
|
|
this.changeDetector = changeDetector;
|
|
this.activated = null;
|
|
this._activatedRoute = null;
|
|
this.activateEvents = new _angular_core.EventEmitter();
|
|
this.deactivateEvents = new _angular_core.EventEmitter();
|
|
this.name = name || PRIMARY_OUTLET;
|
|
parentContexts.onChildOutletCreated(this.name, this);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterOutlet.prototype.ngOnDestroy = /**
|
|
* @return {?}
|
|
*/
|
|
function () { this.parentContexts.onChildOutletDestroyed(this.name); };
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterOutlet.prototype.ngOnInit = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this.activated) {
|
|
// If the outlet was not instantiated at the time the route got activated we need to populate
|
|
// the outlet when it is initialized (ie inside a NgIf)
|
|
var /** @type {?} */ context = this.parentContexts.getContext(this.name);
|
|
if (context && context.route) {
|
|
if (context.attachRef) {
|
|
// `attachRef` is populated when there is an existing component to mount
|
|
this.attach(context.attachRef, context.route);
|
|
}
|
|
else {
|
|
// otherwise the component defined in the configuration is created
|
|
this.activateWith(context.route, context.resolver || null);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
Object.defineProperty(RouterOutlet.prototype, "isActivated", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () { return !!this.activated; },
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(RouterOutlet.prototype, "component", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this.activated)
|
|
throw new Error('Outlet is not activated');
|
|
return this.activated.instance;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(RouterOutlet.prototype, "activatedRoute", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this.activated)
|
|
throw new Error('Outlet is not activated');
|
|
return /** @type {?} */ (this._activatedRoute);
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(RouterOutlet.prototype, "activatedRouteData", {
|
|
get: /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (this._activatedRoute) {
|
|
return this._activatedRoute.snapshot.data;
|
|
}
|
|
return {};
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* Called when the `RouteReuseStrategy` instructs to detach the subtree
|
|
*/
|
|
/**
|
|
* Called when the `RouteReuseStrategy` instructs to detach the subtree
|
|
* @return {?}
|
|
*/
|
|
RouterOutlet.prototype.detach = /**
|
|
* Called when the `RouteReuseStrategy` instructs to detach the subtree
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (!this.activated)
|
|
throw new Error('Outlet is not activated');
|
|
this.location.detach();
|
|
var /** @type {?} */ cmp = this.activated;
|
|
this.activated = null;
|
|
this._activatedRoute = null;
|
|
return cmp;
|
|
};
|
|
/**
|
|
* Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
|
|
*/
|
|
/**
|
|
* Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
|
|
* @param {?} ref
|
|
* @param {?} activatedRoute
|
|
* @return {?}
|
|
*/
|
|
RouterOutlet.prototype.attach = /**
|
|
* Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
|
|
* @param {?} ref
|
|
* @param {?} activatedRoute
|
|
* @return {?}
|
|
*/
|
|
function (ref, activatedRoute) {
|
|
this.activated = ref;
|
|
this._activatedRoute = activatedRoute;
|
|
this.location.insert(ref.hostView);
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterOutlet.prototype.deactivate = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (this.activated) {
|
|
var /** @type {?} */ c = this.component;
|
|
this.activated.destroy();
|
|
this.activated = null;
|
|
this._activatedRoute = null;
|
|
this.deactivateEvents.emit(c);
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} activatedRoute
|
|
* @param {?} resolver
|
|
* @return {?}
|
|
*/
|
|
RouterOutlet.prototype.activateWith = /**
|
|
* @param {?} activatedRoute
|
|
* @param {?} resolver
|
|
* @return {?}
|
|
*/
|
|
function (activatedRoute, resolver) {
|
|
if (this.isActivated) {
|
|
throw new Error('Cannot activate an already activated outlet');
|
|
}
|
|
this._activatedRoute = activatedRoute;
|
|
var /** @type {?} */ snapshot = activatedRoute._futureSnapshot;
|
|
var /** @type {?} */ component = /** @type {?} */ (/** @type {?} */ ((snapshot.routeConfig)).component);
|
|
resolver = resolver || this.resolver;
|
|
var /** @type {?} */ factory = resolver.resolveComponentFactory(component);
|
|
var /** @type {?} */ childContexts = this.parentContexts.getOrCreateContext(this.name).children;
|
|
var /** @type {?} */ injector = new OutletInjector(activatedRoute, childContexts, this.location.injector);
|
|
this.activated = this.location.createComponent(factory, this.location.length, injector);
|
|
// Calling `markForCheck` to make sure we will run the change detection when the
|
|
// `RouterOutlet` is inside a `ChangeDetectionStrategy.OnPush` component.
|
|
this.changeDetector.markForCheck();
|
|
this.activateEvents.emit(this.activated.instance);
|
|
};
|
|
RouterOutlet.decorators = [
|
|
{ type: _angular_core.Directive, args: [{ selector: 'router-outlet', exportAs: 'outlet' },] },
|
|
];
|
|
/** @nocollapse */
|
|
RouterOutlet.ctorParameters = function () { return [
|
|
{ type: ChildrenOutletContexts, },
|
|
{ type: _angular_core.ViewContainerRef, },
|
|
{ type: _angular_core.ComponentFactoryResolver, },
|
|
{ type: undefined, decorators: [{ type: _angular_core.Attribute, args: ['name',] },] },
|
|
{ type: _angular_core.ChangeDetectorRef, },
|
|
]; };
|
|
RouterOutlet.propDecorators = {
|
|
"activateEvents": [{ type: _angular_core.Output, args: ['activate',] },],
|
|
"deactivateEvents": [{ type: _angular_core.Output, args: ['deactivate',] },],
|
|
};
|
|
return RouterOutlet;
|
|
}());
|
|
var OutletInjector = /** @class */ (function () {
|
|
function OutletInjector(route, childContexts, parent) {
|
|
this.route = route;
|
|
this.childContexts = childContexts;
|
|
this.parent = parent;
|
|
}
|
|
/**
|
|
* @param {?} token
|
|
* @param {?=} notFoundValue
|
|
* @return {?}
|
|
*/
|
|
OutletInjector.prototype.get = /**
|
|
* @param {?} token
|
|
* @param {?=} notFoundValue
|
|
* @return {?}
|
|
*/
|
|
function (token, notFoundValue) {
|
|
if (token === ActivatedRoute) {
|
|
return this.route;
|
|
}
|
|
if (token === ChildrenOutletContexts) {
|
|
return this.childContexts;
|
|
}
|
|
return this.parent.get(token, notFoundValue);
|
|
};
|
|
return OutletInjector;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
*@license
|
|
*Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
*Use of this source code is governed by an MIT-style license that can be
|
|
*found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Provides a preloading strategy.
|
|
*
|
|
* \@experimental
|
|
* @abstract
|
|
*/
|
|
var PreloadingStrategy = /** @class */ (function () {
|
|
function PreloadingStrategy() {
|
|
}
|
|
return PreloadingStrategy;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Provides a preloading strategy that preloads all modules as quickly as possible.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* RouteModule.forRoot(ROUTES, {preloadingStrategy: PreloadAllModules})
|
|
* ```
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var PreloadAllModules = /** @class */ (function () {
|
|
function PreloadAllModules() {
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} fn
|
|
* @return {?}
|
|
*/
|
|
PreloadAllModules.prototype.preload = /**
|
|
* @param {?} route
|
|
* @param {?} fn
|
|
* @return {?}
|
|
*/
|
|
function (route, fn) {
|
|
return rxjs_operator_catch._catch.call(fn(), function () { return rxjs_observable_of.of(null); });
|
|
};
|
|
return PreloadAllModules;
|
|
}());
|
|
/**
|
|
* \@whatItDoes Provides a preloading strategy that does not preload any modules.
|
|
*
|
|
* \@description
|
|
*
|
|
* This strategy is enabled by default.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var NoPreloading = /** @class */ (function () {
|
|
function NoPreloading() {
|
|
}
|
|
/**
|
|
* @param {?} route
|
|
* @param {?} fn
|
|
* @return {?}
|
|
*/
|
|
NoPreloading.prototype.preload = /**
|
|
* @param {?} route
|
|
* @param {?} fn
|
|
* @return {?}
|
|
*/
|
|
function (route, fn) { return rxjs_observable_of.of(null); };
|
|
return NoPreloading;
|
|
}());
|
|
/**
|
|
* The preloader optimistically loads all router configurations to
|
|
* make navigations into lazily-loaded sections of the application faster.
|
|
*
|
|
* The preloader runs in the background. When the router bootstraps, the preloader
|
|
* starts listening to all navigation events. After every such event, the preloader
|
|
* will check if any configurations can be loaded lazily.
|
|
*
|
|
* If a route is protected by `canLoad` guards, the preloaded will not load it.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterPreloader = /** @class */ (function () {
|
|
function RouterPreloader(router, moduleLoader, compiler, injector, preloadingStrategy) {
|
|
this.router = router;
|
|
this.injector = injector;
|
|
this.preloadingStrategy = preloadingStrategy;
|
|
var /** @type {?} */ onStartLoad = function (r) { return router.triggerEvent(new RouteConfigLoadStart(r)); };
|
|
var /** @type {?} */ onEndLoad = function (r) { return router.triggerEvent(new RouteConfigLoadEnd(r)); };
|
|
this.loader = new RouterConfigLoader(moduleLoader, compiler, onStartLoad, onEndLoad);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterPreloader.prototype.setUpPreloading = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
var /** @type {?} */ navigations$ = rxjs_operator_filter.filter.call(this.router.events, function (e) { return e instanceof NavigationEnd; });
|
|
this.subscription = rxjs_operator_concatMap.concatMap.call(navigations$, function () { return _this.preload(); }).subscribe(function () { });
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterPreloader.prototype.preload = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var /** @type {?} */ ngModule = this.injector.get(_angular_core.NgModuleRef);
|
|
return this.processRoutes(ngModule, this.router.config);
|
|
};
|
|
// TODO(jasonaden): This class relies on code external to the class to call setUpPreloading. If
|
|
// this hasn't been done, ngOnDestroy will fail as this.subscription will be undefined. This
|
|
// should be refactored.
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterPreloader.prototype.ngOnDestroy = /**
|
|
* @return {?}
|
|
*/
|
|
function () { this.subscription.unsubscribe(); };
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
RouterPreloader.prototype.processRoutes = /**
|
|
* @param {?} ngModule
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, routes) {
|
|
var /** @type {?} */ res = [];
|
|
for (var _i = 0, routes_1 = routes; _i < routes_1.length; _i++) {
|
|
var route = routes_1[_i];
|
|
// we already have the config loaded, just recurse
|
|
if (route.loadChildren && !route.canLoad && route._loadedConfig) {
|
|
var /** @type {?} */ childConfig = route._loadedConfig;
|
|
res.push(this.processRoutes(childConfig.module, childConfig.routes));
|
|
// no config loaded, fetch the config
|
|
}
|
|
else if (route.loadChildren && !route.canLoad) {
|
|
res.push(this.preloadConfig(ngModule, route));
|
|
// recurse into children
|
|
}
|
|
else if (route.children) {
|
|
res.push(this.processRoutes(ngModule, route.children));
|
|
}
|
|
}
|
|
return rxjs_operator_mergeAll.mergeAll.call(rxjs_observable_from.from(res));
|
|
};
|
|
/**
|
|
* @param {?} ngModule
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
RouterPreloader.prototype.preloadConfig = /**
|
|
* @param {?} ngModule
|
|
* @param {?} route
|
|
* @return {?}
|
|
*/
|
|
function (ngModule, route) {
|
|
var _this = this;
|
|
return this.preloadingStrategy.preload(route, function () {
|
|
var /** @type {?} */ loaded$ = _this.loader.load(ngModule.injector, route);
|
|
return rxjs_operator_mergeMap.mergeMap.call(loaded$, function (config) {
|
|
route._loadedConfig = config;
|
|
return _this.processRoutes(config.module, config.routes);
|
|
});
|
|
});
|
|
};
|
|
RouterPreloader.decorators = [
|
|
{ type: _angular_core.Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
RouterPreloader.ctorParameters = function () { return [
|
|
{ type: Router, },
|
|
{ type: _angular_core.NgModuleFactoryLoader, },
|
|
{ type: _angular_core.Compiler, },
|
|
{ type: _angular_core.Injector, },
|
|
{ type: PreloadingStrategy, },
|
|
]; };
|
|
return RouterPreloader;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@whatItDoes Contains a list of directives
|
|
* \@stable
|
|
*/
|
|
var ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive];
|
|
/**
|
|
* \@whatItDoes Is used in DI to configure the router.
|
|
* \@stable
|
|
*/
|
|
var ROUTER_CONFIGURATION = new _angular_core.InjectionToken('ROUTER_CONFIGURATION');
|
|
/**
|
|
* \@docsNotRequired
|
|
*/
|
|
var ROUTER_FORROOT_GUARD = new _angular_core.InjectionToken('ROUTER_FORROOT_GUARD');
|
|
var ROUTER_PROVIDERS = [
|
|
_angular_common.Location,
|
|
{ provide: UrlSerializer, useClass: DefaultUrlSerializer },
|
|
{
|
|
provide: Router,
|
|
useFactory: setupRouter,
|
|
deps: [
|
|
_angular_core.ApplicationRef, UrlSerializer, ChildrenOutletContexts, _angular_common.Location, _angular_core.Injector,
|
|
_angular_core.NgModuleFactoryLoader, _angular_core.Compiler, ROUTES, ROUTER_CONFIGURATION,
|
|
[UrlHandlingStrategy, new _angular_core.Optional()], [RouteReuseStrategy, new _angular_core.Optional()]
|
|
]
|
|
},
|
|
ChildrenOutletContexts,
|
|
{ provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },
|
|
{ provide: _angular_core.NgModuleFactoryLoader, useClass: _angular_core.SystemJsNgModuleLoader },
|
|
RouterPreloader,
|
|
NoPreloading,
|
|
PreloadAllModules,
|
|
{ provide: ROUTER_CONFIGURATION, useValue: { enableTracing: false } },
|
|
];
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
function routerNgProbeToken() {
|
|
return new _angular_core.NgProbeToken('Router', Router);
|
|
}
|
|
/**
|
|
* \@whatItDoes Adds router directives and providers.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* RouterModule can be imported multiple times: once per lazily-loaded bundle.
|
|
* Since the router deals with a global shared resource--location, we cannot have
|
|
* more than one router service active.
|
|
*
|
|
* That is why there are two ways to create the module: `RouterModule.forRoot` and
|
|
* `RouterModule.forChild`.
|
|
*
|
|
* * `forRoot` creates a module that contains all the directives, the given routes, and the router
|
|
* service itself.
|
|
* * `forChild` creates a module that contains all the directives and the given routes, but does not
|
|
* include the router service.
|
|
*
|
|
* When registered at the root, the module should be used as follows
|
|
*
|
|
* ```
|
|
* \@NgModule({
|
|
* imports: [RouterModule.forRoot(ROUTES)]
|
|
* })
|
|
* class MyNgModule {}
|
|
* ```
|
|
*
|
|
* For submodules and lazy loaded submodules the module should be used as follows:
|
|
*
|
|
* ```
|
|
* \@NgModule({
|
|
* imports: [RouterModule.forChild(ROUTES)]
|
|
* })
|
|
* class MyNgModule {}
|
|
* ```
|
|
*
|
|
* \@description
|
|
*
|
|
* Managing state transitions is one of the hardest parts of building applications. This is
|
|
* especially true on the web, where you also need to ensure that the state is reflected in the URL.
|
|
* In addition, we often want to split applications into multiple bundles and load them on demand.
|
|
* Doing this transparently is not trivial.
|
|
*
|
|
* The Angular router solves these problems. Using the router, you can declaratively specify
|
|
* application states, manage state transitions while taking care of the URL, and load bundles on
|
|
* demand.
|
|
*
|
|
* [Read this developer guide](https://angular.io/docs/ts/latest/guide/router.html) to get an
|
|
* overview of how the router should be used.
|
|
*
|
|
* \@stable
|
|
*/
|
|
var RouterModule = /** @class */ (function () {
|
|
// Note: We are injecting the Router so it gets created eagerly...
|
|
function RouterModule(guard, router) {
|
|
}
|
|
/**
|
|
* Creates a module with all the router providers and directives. It also optionally sets up an
|
|
* application listener to perform an initial navigation.
|
|
*
|
|
* Options (see {@link ExtraOptions}):
|
|
* * `enableTracing` makes the router log all its internal events to the console.
|
|
* * `useHash` enables the location strategy that uses the URL fragment instead of the history
|
|
* API.
|
|
* * `initialNavigation` disables the initial navigation.
|
|
* * `errorHandler` provides a custom error handler.
|
|
* * `preloadingStrategy` configures a preloading strategy (see {@link PreloadAllModules}).
|
|
* * `onSameUrlNavigation` configures how the router handles navigation to the current URL. See
|
|
* {@link ExtraOptions} for more details.
|
|
*/
|
|
/**
|
|
* Creates a module with all the router providers and directives. It also optionally sets up an
|
|
* application listener to perform an initial navigation.
|
|
*
|
|
* Options (see {\@link ExtraOptions}):
|
|
* * `enableTracing` makes the router log all its internal events to the console.
|
|
* * `useHash` enables the location strategy that uses the URL fragment instead of the history
|
|
* API.
|
|
* * `initialNavigation` disables the initial navigation.
|
|
* * `errorHandler` provides a custom error handler.
|
|
* * `preloadingStrategy` configures a preloading strategy (see {\@link PreloadAllModules}).
|
|
* * `onSameUrlNavigation` configures how the router handles navigation to the current URL. See
|
|
* {\@link ExtraOptions} for more details.
|
|
* @param {?} routes
|
|
* @param {?=} config
|
|
* @return {?}
|
|
*/
|
|
RouterModule.forRoot = /**
|
|
* Creates a module with all the router providers and directives. It also optionally sets up an
|
|
* application listener to perform an initial navigation.
|
|
*
|
|
* Options (see {\@link ExtraOptions}):
|
|
* * `enableTracing` makes the router log all its internal events to the console.
|
|
* * `useHash` enables the location strategy that uses the URL fragment instead of the history
|
|
* API.
|
|
* * `initialNavigation` disables the initial navigation.
|
|
* * `errorHandler` provides a custom error handler.
|
|
* * `preloadingStrategy` configures a preloading strategy (see {\@link PreloadAllModules}).
|
|
* * `onSameUrlNavigation` configures how the router handles navigation to the current URL. See
|
|
* {\@link ExtraOptions} for more details.
|
|
* @param {?} routes
|
|
* @param {?=} config
|
|
* @return {?}
|
|
*/
|
|
function (routes, config) {
|
|
return {
|
|
ngModule: RouterModule,
|
|
providers: [
|
|
ROUTER_PROVIDERS,
|
|
provideRoutes(routes),
|
|
{
|
|
provide: ROUTER_FORROOT_GUARD,
|
|
useFactory: provideForRootGuard,
|
|
deps: [[Router, new _angular_core.Optional(), new _angular_core.SkipSelf()]]
|
|
},
|
|
{ provide: ROUTER_CONFIGURATION, useValue: config ? config : {} },
|
|
{
|
|
provide: _angular_common.LocationStrategy,
|
|
useFactory: provideLocationStrategy,
|
|
deps: [
|
|
_angular_common.PlatformLocation, [new _angular_core.Inject(_angular_common.APP_BASE_HREF), new _angular_core.Optional()], ROUTER_CONFIGURATION
|
|
]
|
|
},
|
|
{
|
|
provide: PreloadingStrategy,
|
|
useExisting: config && config.preloadingStrategy ? config.preloadingStrategy :
|
|
NoPreloading
|
|
},
|
|
{ provide: _angular_core.NgProbeToken, multi: true, useFactory: routerNgProbeToken },
|
|
provideRouterInitializer(),
|
|
],
|
|
};
|
|
};
|
|
/**
|
|
* Creates a module with all the router directives and a provider registering routes.
|
|
*/
|
|
/**
|
|
* Creates a module with all the router directives and a provider registering routes.
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
RouterModule.forChild = /**
|
|
* Creates a module with all the router directives and a provider registering routes.
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function (routes) {
|
|
return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
|
|
};
|
|
RouterModule.decorators = [
|
|
{ type: _angular_core.NgModule, args: [{ declarations: ROUTER_DIRECTIVES, exports: ROUTER_DIRECTIVES },] },
|
|
];
|
|
/** @nocollapse */
|
|
RouterModule.ctorParameters = function () { return [
|
|
{ type: undefined, decorators: [{ type: _angular_core.Optional }, { type: _angular_core.Inject, args: [ROUTER_FORROOT_GUARD,] },] },
|
|
{ type: Router, decorators: [{ type: _angular_core.Optional },] },
|
|
]; };
|
|
return RouterModule;
|
|
}());
|
|
/**
|
|
* @param {?} platformLocationStrategy
|
|
* @param {?} baseHref
|
|
* @param {?=} options
|
|
* @return {?}
|
|
*/
|
|
function provideLocationStrategy(platformLocationStrategy, baseHref, options) {
|
|
if (options === void 0) { options = {}; }
|
|
return options.useHash ? new _angular_common.HashLocationStrategy(platformLocationStrategy, baseHref) :
|
|
new _angular_common.PathLocationStrategy(platformLocationStrategy, baseHref);
|
|
}
|
|
/**
|
|
* @param {?} router
|
|
* @return {?}
|
|
*/
|
|
function provideForRootGuard(router) {
|
|
if (router) {
|
|
throw new Error("RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.");
|
|
}
|
|
return 'guarded';
|
|
}
|
|
/**
|
|
* \@whatItDoes Registers routes.
|
|
*
|
|
* \@howToUse
|
|
*
|
|
* ```
|
|
* \@NgModule({
|
|
* imports: [RouterModule.forChild(ROUTES)],
|
|
* providers: [provideRoutes(EXTRA_ROUTES)]
|
|
* })
|
|
* class MyNgModule {}
|
|
* ```
|
|
*
|
|
* \@stable
|
|
* @param {?} routes
|
|
* @return {?}
|
|
*/
|
|
function provideRoutes(routes) {
|
|
return [
|
|
{ provide: _angular_core.ANALYZE_FOR_ENTRY_COMPONENTS, multi: true, useValue: routes },
|
|
{ provide: ROUTES, multi: true, useValue: routes },
|
|
];
|
|
}
|
|
/**
|
|
* \@whatItDoes Represents options to configure the router.
|
|
*
|
|
* \@stable
|
|
* @record
|
|
*/
|
|
|
|
/**
|
|
* @param {?} ref
|
|
* @param {?} urlSerializer
|
|
* @param {?} contexts
|
|
* @param {?} location
|
|
* @param {?} injector
|
|
* @param {?} loader
|
|
* @param {?} compiler
|
|
* @param {?} config
|
|
* @param {?=} opts
|
|
* @param {?=} urlHandlingStrategy
|
|
* @param {?=} routeReuseStrategy
|
|
* @return {?}
|
|
*/
|
|
function setupRouter(ref, urlSerializer, contexts, location, injector, loader, compiler, config, opts, urlHandlingStrategy, routeReuseStrategy) {
|
|
if (opts === void 0) { opts = {}; }
|
|
var /** @type {?} */ router = new Router(null, urlSerializer, contexts, location, injector, loader, compiler, flatten(config));
|
|
if (urlHandlingStrategy) {
|
|
router.urlHandlingStrategy = urlHandlingStrategy;
|
|
}
|
|
if (routeReuseStrategy) {
|
|
router.routeReuseStrategy = routeReuseStrategy;
|
|
}
|
|
if (opts.errorHandler) {
|
|
router.errorHandler = opts.errorHandler;
|
|
}
|
|
if (opts.enableTracing) {
|
|
var /** @type {?} */ dom_1 = _angular_platformBrowser.ɵgetDOM();
|
|
router.events.subscribe(function (e) {
|
|
dom_1.logGroup("Router Event: " + ((/** @type {?} */ (e.constructor))).name);
|
|
dom_1.log(e.toString());
|
|
dom_1.log(e);
|
|
dom_1.logGroupEnd();
|
|
});
|
|
}
|
|
if (opts.onSameUrlNavigation) {
|
|
router.onSameUrlNavigation = opts.onSameUrlNavigation;
|
|
}
|
|
if (opts.paramsInheritanceStrategy) {
|
|
router.paramsInheritanceStrategy = opts.paramsInheritanceStrategy;
|
|
}
|
|
return router;
|
|
}
|
|
/**
|
|
* @param {?} router
|
|
* @return {?}
|
|
*/
|
|
function rootRoute(router) {
|
|
return router.routerState.root;
|
|
}
|
|
/**
|
|
* To initialize the router properly we need to do in two steps:
|
|
*
|
|
* We need to start the navigation in a APP_INITIALIZER to block the bootstrap if
|
|
* a resolver or a guards executes asynchronously. Second, we need to actually run
|
|
* activation in a BOOTSTRAP_LISTENER. We utilize the afterPreactivation
|
|
* hook provided by the router to do that.
|
|
*
|
|
* The router navigation starts, reaches the point when preactivation is done, and then
|
|
* pauses. It waits for the hook to be resolved. We then resolve it only in a bootstrap listener.
|
|
*/
|
|
var RouterInitializer = /** @class */ (function () {
|
|
function RouterInitializer(injector) {
|
|
this.injector = injector;
|
|
this.initNavigation = false;
|
|
this.resultOfPreactivationDone = new rxjs_Subject.Subject();
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
RouterInitializer.prototype.appInitializer = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
var /** @type {?} */ p = this.injector.get(_angular_common.LOCATION_INITIALIZED, Promise.resolve(null));
|
|
return p.then(function () {
|
|
var /** @type {?} */ resolve = /** @type {?} */ ((null));
|
|
var /** @type {?} */ res = new Promise(function (r) { return resolve = r; });
|
|
var /** @type {?} */ router = _this.injector.get(Router);
|
|
var /** @type {?} */ opts = _this.injector.get(ROUTER_CONFIGURATION);
|
|
if (_this.isLegacyDisabled(opts) || _this.isLegacyEnabled(opts)) {
|
|
resolve(true);
|
|
}
|
|
else if (opts.initialNavigation === 'disabled') {
|
|
router.setUpLocationChangeListener();
|
|
resolve(true);
|
|
}
|
|
else if (opts.initialNavigation === 'enabled') {
|
|
router.hooks.afterPreactivation = function () {
|
|
// only the initial navigation should be delayed
|
|
if (!_this.initNavigation) {
|
|
_this.initNavigation = true;
|
|
resolve(true);
|
|
return _this.resultOfPreactivationDone;
|
|
// subsequent navigations should not be delayed
|
|
}
|
|
else {
|
|
return /** @type {?} */ (rxjs_observable_of.of(null));
|
|
}
|
|
};
|
|
router.initialNavigation();
|
|
}
|
|
else {
|
|
throw new Error("Invalid initialNavigation options: '" + opts.initialNavigation + "'");
|
|
}
|
|
return res;
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} bootstrappedComponentRef
|
|
* @return {?}
|
|
*/
|
|
RouterInitializer.prototype.bootstrapListener = /**
|
|
* @param {?} bootstrappedComponentRef
|
|
* @return {?}
|
|
*/
|
|
function (bootstrappedComponentRef) {
|
|
var /** @type {?} */ opts = this.injector.get(ROUTER_CONFIGURATION);
|
|
var /** @type {?} */ preloader = this.injector.get(RouterPreloader);
|
|
var /** @type {?} */ router = this.injector.get(Router);
|
|
var /** @type {?} */ ref = this.injector.get(_angular_core.ApplicationRef);
|
|
if (bootstrappedComponentRef !== ref.components[0]) {
|
|
return;
|
|
}
|
|
if (this.isLegacyEnabled(opts)) {
|
|
router.initialNavigation();
|
|
}
|
|
else if (this.isLegacyDisabled(opts)) {
|
|
router.setUpLocationChangeListener();
|
|
}
|
|
preloader.setUpPreloading();
|
|
router.resetRootComponentType(ref.componentTypes[0]);
|
|
this.resultOfPreactivationDone.next(/** @type {?} */ ((null)));
|
|
this.resultOfPreactivationDone.complete();
|
|
};
|
|
/**
|
|
* @param {?} opts
|
|
* @return {?}
|
|
*/
|
|
RouterInitializer.prototype.isLegacyEnabled = /**
|
|
* @param {?} opts
|
|
* @return {?}
|
|
*/
|
|
function (opts) {
|
|
return opts.initialNavigation === 'legacy_enabled' || opts.initialNavigation === true ||
|
|
opts.initialNavigation === undefined;
|
|
};
|
|
/**
|
|
* @param {?} opts
|
|
* @return {?}
|
|
*/
|
|
RouterInitializer.prototype.isLegacyDisabled = /**
|
|
* @param {?} opts
|
|
* @return {?}
|
|
*/
|
|
function (opts) {
|
|
return opts.initialNavigation === 'legacy_disabled' || opts.initialNavigation === false;
|
|
};
|
|
RouterInitializer.decorators = [
|
|
{ type: _angular_core.Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
RouterInitializer.ctorParameters = function () { return [
|
|
{ type: _angular_core.Injector, },
|
|
]; };
|
|
return RouterInitializer;
|
|
}());
|
|
/**
|
|
* @param {?} r
|
|
* @return {?}
|
|
*/
|
|
function getAppInitializer(r) {
|
|
return r.appInitializer.bind(r);
|
|
}
|
|
/**
|
|
* @param {?} r
|
|
* @return {?}
|
|
*/
|
|
function getBootstrapListener(r) {
|
|
return r.bootstrapListener.bind(r);
|
|
}
|
|
/**
|
|
* A token for the router initializer that will be called after the app is bootstrapped.
|
|
*
|
|
* \@experimental
|
|
*/
|
|
var ROUTER_INITIALIZER = new _angular_core.InjectionToken('Router Initializer');
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
function provideRouterInitializer() {
|
|
return [
|
|
RouterInitializer,
|
|
{
|
|
provide: _angular_core.APP_INITIALIZER,
|
|
multi: true,
|
|
useFactory: getAppInitializer,
|
|
deps: [RouterInitializer]
|
|
},
|
|
{ provide: ROUTER_INITIALIZER, useFactory: getBootstrapListener, deps: [RouterInitializer] },
|
|
{ provide: _angular_core.APP_BOOTSTRAP_LISTENER, multi: true, useExisting: ROUTER_INITIALIZER },
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/**
|
|
* \@stable
|
|
*/
|
|
var VERSION = new _angular_core.Version('6.0.0-beta.2-8c5c0dac1');
|
|
|
|
exports.RouterLink = RouterLink;
|
|
exports.RouterLinkWithHref = RouterLinkWithHref;
|
|
exports.RouterLinkActive = RouterLinkActive;
|
|
exports.RouterOutlet = RouterOutlet;
|
|
exports.ActivationEnd = ActivationEnd;
|
|
exports.ActivationStart = ActivationStart;
|
|
exports.ChildActivationEnd = ChildActivationEnd;
|
|
exports.ChildActivationStart = ChildActivationStart;
|
|
exports.GuardsCheckEnd = GuardsCheckEnd;
|
|
exports.GuardsCheckStart = GuardsCheckStart;
|
|
exports.NavigationCancel = NavigationCancel;
|
|
exports.NavigationEnd = NavigationEnd;
|
|
exports.NavigationError = NavigationError;
|
|
exports.NavigationStart = NavigationStart;
|
|
exports.ResolveEnd = ResolveEnd;
|
|
exports.ResolveStart = ResolveStart;
|
|
exports.RouteConfigLoadEnd = RouteConfigLoadEnd;
|
|
exports.RouteConfigLoadStart = RouteConfigLoadStart;
|
|
exports.RouterEvent = RouterEvent;
|
|
exports.RoutesRecognized = RoutesRecognized;
|
|
exports.RouteReuseStrategy = RouteReuseStrategy;
|
|
exports.Router = Router;
|
|
exports.ROUTES = ROUTES;
|
|
exports.ROUTER_CONFIGURATION = ROUTER_CONFIGURATION;
|
|
exports.ROUTER_INITIALIZER = ROUTER_INITIALIZER;
|
|
exports.RouterModule = RouterModule;
|
|
exports.provideRoutes = provideRoutes;
|
|
exports.ChildrenOutletContexts = ChildrenOutletContexts;
|
|
exports.OutletContext = OutletContext;
|
|
exports.NoPreloading = NoPreloading;
|
|
exports.PreloadAllModules = PreloadAllModules;
|
|
exports.PreloadingStrategy = PreloadingStrategy;
|
|
exports.RouterPreloader = RouterPreloader;
|
|
exports.ActivatedRoute = ActivatedRoute;
|
|
exports.ActivatedRouteSnapshot = ActivatedRouteSnapshot;
|
|
exports.RouterState = RouterState;
|
|
exports.RouterStateSnapshot = RouterStateSnapshot;
|
|
exports.PRIMARY_OUTLET = PRIMARY_OUTLET;
|
|
exports.convertToParamMap = convertToParamMap;
|
|
exports.UrlHandlingStrategy = UrlHandlingStrategy;
|
|
exports.DefaultUrlSerializer = DefaultUrlSerializer;
|
|
exports.UrlSegment = UrlSegment;
|
|
exports.UrlSegmentGroup = UrlSegmentGroup;
|
|
exports.UrlSerializer = UrlSerializer;
|
|
exports.UrlTree = UrlTree;
|
|
exports.VERSION = VERSION;
|
|
exports.ɵROUTER_PROVIDERS = ROUTER_PROVIDERS;
|
|
exports.ɵflatten = flatten;
|
|
exports.ɵa = ROUTER_FORROOT_GUARD;
|
|
exports.ɵg = RouterInitializer;
|
|
exports.ɵh = getAppInitializer;
|
|
exports.ɵi = getBootstrapListener;
|
|
exports.ɵd = provideForRootGuard;
|
|
exports.ɵc = provideLocationStrategy;
|
|
exports.ɵj = provideRouterInitializer;
|
|
exports.ɵf = rootRoute;
|
|
exports.ɵb = routerNgProbeToken;
|
|
exports.ɵe = setupRouter;
|
|
exports.ɵk = Tree;
|
|
exports.ɵl = TreeNode;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|
|
//# sourceMappingURL=router.umd.js.map
|