@angular/router
Version:
Angular - the routing library
667 lines (666 loc) • 64.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} 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
*/
import { APP_BASE_HREF, HashLocationStrategy, LOCATION_INITIALIZED, Location, LocationStrategy, PathLocationStrategy, PlatformLocation, ViewportScroller } from '@angular/common';
import { ANALYZE_FOR_ENTRY_COMPONENTS, APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationRef, Compiler, Inject, Injectable, InjectionToken, Injector, NgModule, NgModuleFactoryLoader, NgProbeToken, Optional, SkipSelf, SystemJsNgModuleLoader } from '@angular/core';
import { ɵgetDOM as getDOM } from '@angular/platform-browser';
import { Subject, of } from 'rxjs';
import { EmptyOutletComponent } from './components/empty_outlet';
import { RouterLink, RouterLinkWithHref } from './directives/router_link';
import { RouterLinkActive } from './directives/router_link_active';
import { RouterOutlet } from './directives/router_outlet';
import { RouteReuseStrategy } from './route_reuse_strategy';
import { Router } from './router';
import { ROUTES } from './router_config_loader';
import { ChildrenOutletContexts } from './router_outlet_context';
import { NoPreloading, PreloadAllModules, PreloadingStrategy, RouterPreloader } from './router_preloader';
import { RouterScroller } from './router_scroller';
import { ActivatedRoute } from './router_state';
import { UrlHandlingStrategy } from './url_handling_strategy';
import { DefaultUrlSerializer, UrlSerializer } from './url_tree';
import { flatten } from './utils/collection';
/** *
* \@description
*
* Contains a list of directives
*
*
@type {?} */
const ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, EmptyOutletComponent];
/** *
* \@description
*
* Is used in DI to configure the router.
*
* \@publicApi
@type {?} */
export const ROUTER_CONFIGURATION = new InjectionToken('ROUTER_CONFIGURATION');
/** *
* \@docsNotRequired
@type {?} */
export const ROUTER_FORROOT_GUARD = new InjectionToken('ROUTER_FORROOT_GUARD');
/** @type {?} */
export const ROUTER_PROVIDERS = [
Location,
{ provide: UrlSerializer, useClass: DefaultUrlSerializer },
{
provide: Router,
useFactory: setupRouter,
deps: [
ApplicationRef, UrlSerializer, ChildrenOutletContexts, Location, Injector,
NgModuleFactoryLoader, Compiler, ROUTES, ROUTER_CONFIGURATION,
[UrlHandlingStrategy, new Optional()], [RouteReuseStrategy, new Optional()]
]
},
ChildrenOutletContexts,
{ provide: ActivatedRoute, useFactory: rootRoute, deps: [Router] },
{ provide: NgModuleFactoryLoader, useClass: SystemJsNgModuleLoader },
RouterPreloader,
NoPreloading,
PreloadAllModules,
{ provide: ROUTER_CONFIGURATION, useValue: { enableTracing: false } },
];
/**
* @return {?}
*/
export function routerNgProbeToken() {
return new NgProbeToken('Router', Router);
}
/**
* \@usageNotes
*
* 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
*
* Adds router directives and providers.
*
* 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.
*
* \@publicApi
*/
export class RouterModule {
/**
* @param {?} guard
* @param {?} router
*/
constructor(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 `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 `PreloadAllModules`).
* * `onSameUrlNavigation` configures how the router handles navigation to the current URL. See
* `ExtraOptions` for more details.
* * `paramsInheritanceStrategy` defines how the router merges params, data and resolved data
* from parent to child routes.
* @param {?} routes
* @param {?=} config
* @return {?}
*/
static forRoot(routes, config) {
return {
ngModule: RouterModule,
providers: [
ROUTER_PROVIDERS,
provideRoutes(routes),
{
provide: ROUTER_FORROOT_GUARD,
useFactory: provideForRootGuard,
deps: [[Router, new Optional(), new SkipSelf()]]
},
{ provide: ROUTER_CONFIGURATION, useValue: config ? config : {} },
{
provide: LocationStrategy,
useFactory: provideLocationStrategy,
deps: [
PlatformLocation, [new Inject(APP_BASE_HREF), new Optional()], ROUTER_CONFIGURATION
]
},
{
provide: RouterScroller,
useFactory: createRouterScroller,
deps: [Router, ViewportScroller, ROUTER_CONFIGURATION]
},
{
provide: PreloadingStrategy,
useExisting: config && config.preloadingStrategy ? config.preloadingStrategy :
NoPreloading
},
{ provide: NgProbeToken, multi: true, useFactory: routerNgProbeToken },
provideRouterInitializer(),
],
};
}
/**
* Creates a module with all the router directives and a provider registering routes.
* @param {?} routes
* @return {?}
*/
static forChild(routes) {
return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
}
}
RouterModule.decorators = [
{ type: NgModule, args: [{
declarations: ROUTER_DIRECTIVES,
exports: ROUTER_DIRECTIVES,
entryComponents: [EmptyOutletComponent]
},] }
];
/** @nocollapse */
RouterModule.ctorParameters = () => [
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [ROUTER_FORROOT_GUARD,] }] },
{ type: Router, decorators: [{ type: Optional }] }
];
/**
* @param {?} router
* @param {?} viewportScroller
* @param {?} config
* @return {?}
*/
export function createRouterScroller(router, viewportScroller, config) {
if (config.scrollOffset) {
viewportScroller.setOffset(config.scrollOffset);
}
return new RouterScroller(router, viewportScroller, config);
}
/**
* @param {?} platformLocationStrategy
* @param {?} baseHref
* @param {?=} options
* @return {?}
*/
export function provideLocationStrategy(platformLocationStrategy, baseHref, options = {}) {
return options.useHash ? new HashLocationStrategy(platformLocationStrategy, baseHref) :
new PathLocationStrategy(platformLocationStrategy, baseHref);
}
/**
* @param {?} router
* @return {?}
*/
export function provideForRootGuard(router) {
if (router) {
throw new Error(`RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);
}
return 'guarded';
}
/**
* \@description
*
* Registers routes.
*
* \@usageNotes
* ### Example
*
* ```
* \@NgModule({
* imports: [RouterModule.forChild(ROUTES)],
* providers: [provideRoutes(EXTRA_ROUTES)]
* })
* class MyNgModule {}
* ```
*
* \@publicApi
* @param {?} routes
* @return {?}
*/
export function provideRoutes(routes) {
return [
{ provide: ANALYZE_FOR_ENTRY_COMPONENTS, multi: true, useValue: routes },
{ provide: ROUTES, multi: true, useValue: routes },
];
}
/** @typedef {?} */
var InitialNavigation;
export { InitialNavigation };
/**
* \@description
*
* Represents options to configure the router.
*
* \@publicApi
* @record
*/
export function ExtraOptions() { }
/**
* Makes the router log all its internal events to the console.
* @type {?|undefined}
*/
ExtraOptions.prototype.enableTracing;
/**
* Enables the location strategy that uses the URL fragment instead of the history API.
* @type {?|undefined}
*/
ExtraOptions.prototype.useHash;
/**
* Disables the initial navigation.
* @type {?|undefined}
*/
ExtraOptions.prototype.initialNavigation;
/**
* A custom error handler.
* @type {?|undefined}
*/
ExtraOptions.prototype.errorHandler;
/**
* Configures a preloading strategy. See `PreloadAllModules`.
* @type {?|undefined}
*/
ExtraOptions.prototype.preloadingStrategy;
/**
* 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'.
* @type {?|undefined}
*/
ExtraOptions.prototype.onSameUrlNavigation;
/**
* Configures if the scroll position needs to be restored when navigating back.
*
* * 'disabled'--does nothing (default).
* * 'top'--set the scroll position to 0,0..
* * 'enabled'--set the scroll position to the stored position. This option will be the default in
* the future.
*
* When enabled, the router stores and restores scroll positions during navigation.
* When navigating forward, the scroll position will be set to [0, 0], or to the anchor
* if one is provided.
*
* You can implement custom scroll restoration behavior as follows.
* ```typescript
* class AppModule {
* constructor(router: Router, viewportScroller: ViewportScroller, store: Store<AppState>) {
* router.events.pipe(filter(e => e instanceof Scroll), switchMap(e => {
* return store.pipe(first(), timeout(200), map(() => e));
* }).subscribe(e => {
* if (e.position) {
* viewportScroller.scrollToPosition(e.position);
* } else if (e.anchor) {
* viewportScroller.scrollToAnchor(e.anchor);
* } else {
* viewportScroller.scrollToPosition([0, 0]);
* }
* });
* }
* }
* ```
*
* You can also implement component-specific scrolling like this:
*
* ```typescript
* class ListComponent {
* list: any[];
* constructor(router: Router, viewportScroller: ViewportScroller, fetcher: ListFetcher) {
* const scrollEvents = router.events.filter(e => e instanceof Scroll);
* listFetcher.fetch().pipe(withLatestFrom(scrollEvents)).subscribe(([list, e]) => {
* this.list = list;
* if (e.position) {
* viewportScroller.scrollToPosition(e.position);
* } else {
* viewportScroller.scrollToPosition([0, 0]);
* }
* });
* }
* }
* @type {?|undefined}
*/
ExtraOptions.prototype.scrollPositionRestoration;
/**
* Configures if the router should scroll to the element when the url has a fragment.
*
* * 'disabled'--does nothing (default).
* * 'enabled'--scrolls to the element. This option will be the default in the future.
*
* Anchor scrolling does not happen on 'popstate'. Instead, we restore the position
* that we stored or scroll to the top.
* @type {?|undefined}
*/
ExtraOptions.prototype.anchorScrolling;
/**
* Configures the scroll offset the router will use when scrolling to an element.
*
* When given a tuple with two numbers, the router will always use the numbers.
* When given a function, the router will invoke the function every time it restores scroll
* position.
* @type {?|undefined}
*/
ExtraOptions.prototype.scrollOffset;
/**
* 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.
* @type {?|undefined}
*/
ExtraOptions.prototype.paramsInheritanceStrategy;
/**
* A custom malformed uri error handler function. This handler is invoked when encodedURI contains
* invalid character sequences. The default implementation is to redirect to the root url dropping
* any path or param info. This function passes three parameters:
*
* - `'URIError'` - Error thrown when parsing a bad URL
* - `'UrlSerializer'` - UrlSerializer that’s configured with the router.
* - `'url'` - The malformed URL that caused the URIError
*
* @type {?|undefined}
*/
ExtraOptions.prototype.malformedUriErrorHandler;
/**
* Defines when the router updates the browser URL. The default behavior is to update after
* successful navigation. However, some applications may prefer a mode where the URL gets
* updated at the beginning of navigation. The most common use case would be updating the
* URL early so if navigation fails, you can show an error message with the URL that failed.
* Available options are:
*
* - `'deferred'`, the default, updates the browser URL after navigation has finished.
* - `'eager'`, updates browser URL at the beginning of navigation.
* @type {?|undefined}
*/
ExtraOptions.prototype.urlUpdateStrategy;
/**
* Enables a bug fix that corrects relative link resolution in components with empty paths.
* Example:
*
* ```
* const routes = [
* {
* path: '',
* component: ContainerComponent,
* children: [
* { path: 'a', component: AComponent },
* { path: 'b', component: BComponent },
* ]
* }
* ];
* ```
*
* From the `ContainerComponent`, this will not work:
*
* `<a [routerLink]="['./a']">Link to A</a>`
*
* However, this will work:
*
* `<a [routerLink]="['../a']">Link to A</a>`
*
* In other words, you're required to use `../` rather than `./`. The current default in v6
* is `legacy`, and this option will be removed in v7 to default to the corrected behavior.
* @type {?|undefined}
*/
ExtraOptions.prototype.relativeLinkResolution;
/**
* @param {?} ref
* @param {?} urlSerializer
* @param {?} contexts
* @param {?} location
* @param {?} injector
* @param {?} loader
* @param {?} compiler
* @param {?} config
* @param {?=} opts
* @param {?=} urlHandlingStrategy
* @param {?=} routeReuseStrategy
* @return {?}
*/
export function setupRouter(ref, urlSerializer, contexts, location, injector, loader, compiler, config, opts = {}, urlHandlingStrategy, routeReuseStrategy) {
/** @type {?} */
const 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.malformedUriErrorHandler) {
router.malformedUriErrorHandler = opts.malformedUriErrorHandler;
}
if (opts.enableTracing) {
/** @type {?} */
const dom = getDOM();
router.events.subscribe((e) => {
dom.logGroup(`Router Event: ${((/** @type {?} */ (e.constructor))).name}`);
dom.log(e.toString());
dom.log(e);
dom.logGroupEnd();
});
}
if (opts.onSameUrlNavigation) {
router.onSameUrlNavigation = opts.onSameUrlNavigation;
}
if (opts.paramsInheritanceStrategy) {
router.paramsInheritanceStrategy = opts.paramsInheritanceStrategy;
}
if (opts.urlUpdateStrategy) {
router.urlUpdateStrategy = opts.urlUpdateStrategy;
}
if (opts.relativeLinkResolution) {
router.relativeLinkResolution = opts.relativeLinkResolution;
}
return router;
}
/**
* @param {?} router
* @return {?}
*/
export 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.
*/
export class RouterInitializer {
/**
* @param {?} injector
*/
constructor(injector) {
this.injector = injector;
this.initNavigation = false;
this.resultOfPreactivationDone = new Subject();
}
/**
* @return {?}
*/
appInitializer() {
/** @type {?} */
const p = this.injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
return p.then(() => {
/** @type {?} */
let resolve = /** @type {?} */ ((null));
/** @type {?} */
const res = new Promise(r => resolve = r);
/** @type {?} */
const router = this.injector.get(Router);
/** @type {?} */
const 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 = () => {
// 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 {?} */ (of(null));
}
};
router.initialNavigation();
}
else {
throw new Error(`Invalid initialNavigation options: '${opts.initialNavigation}'`);
}
return res;
});
}
/**
* @param {?} bootstrappedComponentRef
* @return {?}
*/
bootstrapListener(bootstrappedComponentRef) {
/** @type {?} */
const opts = this.injector.get(ROUTER_CONFIGURATION);
/** @type {?} */
const preloader = this.injector.get(RouterPreloader);
/** @type {?} */
const routerScroller = this.injector.get(RouterScroller);
/** @type {?} */
const router = this.injector.get(Router);
/** @type {?} */
const ref = this.injector.get(ApplicationRef);
if (bootstrappedComponentRef !== ref.components[0]) {
return;
}
if (this.isLegacyEnabled(opts)) {
router.initialNavigation();
}
else if (this.isLegacyDisabled(opts)) {
router.setUpLocationChangeListener();
}
preloader.setUpPreloading();
routerScroller.init();
router.resetRootComponentType(ref.componentTypes[0]);
this.resultOfPreactivationDone.next(/** @type {?} */ ((null)));
this.resultOfPreactivationDone.complete();
}
/**
* @param {?} opts
* @return {?}
*/
isLegacyEnabled(opts) {
return opts.initialNavigation === 'legacy_enabled' || opts.initialNavigation === true ||
opts.initialNavigation === undefined;
}
/**
* @param {?} opts
* @return {?}
*/
isLegacyDisabled(opts) {
return opts.initialNavigation === 'legacy_disabled' || opts.initialNavigation === false;
}
}
RouterInitializer.decorators = [
{ type: Injectable }
];
/** @nocollapse */
RouterInitializer.ctorParameters = () => [
{ type: Injector }
];
if (false) {
/** @type {?} */
RouterInitializer.prototype.initNavigation;
/** @type {?} */
RouterInitializer.prototype.resultOfPreactivationDone;
/** @type {?} */
RouterInitializer.prototype.injector;
}
/**
* @param {?} r
* @return {?}
*/
export function getAppInitializer(r) {
return r.appInitializer.bind(r);
}
/**
* @param {?} r
* @return {?}
*/
export function getBootstrapListener(r) {
return r.bootstrapListener.bind(r);
}
/** *
* A token for the router initializer that will be called after the app is bootstrapped.
*
* \@publicApi
@type {?} */
export const ROUTER_INITIALIZER = new InjectionToken('Router Initializer');
/**
* @return {?}
*/
export function provideRouterInitializer() {
return [
RouterInitializer,
{
provide: APP_INITIALIZER,
multi: true,
useFactory: getAppInitializer,
deps: [RouterInitializer]
},
{ provide: ROUTER_INITIALIZER, useFactory: getBootstrapListener, deps: [RouterInitializer] },
{ provide: APP_BOOTSTRAP_LISTENER, multi: true, useExisting: ROUTER_INITIALIZER },
];
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router_module.js","sourceRoot":"","sources":["../../../../../../packages/router/src/router_module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {APP_BASE_HREF, HashLocationStrategy, LOCATION_INITIALIZED, Location, LocationStrategy, PathLocationStrategy, PlatformLocation, ViewportScroller} from '@angular/common';\nimport {ANALYZE_FOR_ENTRY_COMPONENTS, APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationRef, Compiler, ComponentRef, Inject, Injectable, InjectionToken, Injector, ModuleWithProviders, NgModule, NgModuleFactoryLoader, NgProbeToken, Optional, Provider, SkipSelf, SystemJsNgModuleLoader} from '@angular/core';\nimport {ɵgetDOM as getDOM} from '@angular/platform-browser';\nimport {Subject, of } from 'rxjs';\n\nimport {EmptyOutletComponent} from './components/empty_outlet';\nimport {Route, Routes} from './config';\nimport {RouterLink, RouterLinkWithHref} from './directives/router_link';\nimport {RouterLinkActive} from './directives/router_link_active';\nimport {RouterOutlet} from './directives/router_outlet';\nimport {RouterEvent} from './events';\nimport {RouteReuseStrategy} from './route_reuse_strategy';\nimport {ErrorHandler, Router} from './router';\nimport {ROUTES} from './router_config_loader';\nimport {ChildrenOutletContexts} from './router_outlet_context';\nimport {NoPreloading, PreloadAllModules, PreloadingStrategy, RouterPreloader} from './router_preloader';\nimport {RouterScroller} from './router_scroller';\nimport {ActivatedRoute} from './router_state';\nimport {UrlHandlingStrategy} from './url_handling_strategy';\nimport {DefaultUrlSerializer, UrlSerializer, UrlTree} from './url_tree';\nimport {flatten} from './utils/collection';\n\n\n\n/**\n * @description\n *\n * Contains a list of directives\n *\n *\n */\nconst ROUTER_DIRECTIVES =\n    [RouterOutlet, RouterLink, RouterLinkWithHref, RouterLinkActive, EmptyOutletComponent];\n\n/**\n * @description\n *\n * Is used in DI to configure the router.\n *\n * @publicApi\n */\nexport const ROUTER_CONFIGURATION = new InjectionToken<ExtraOptions>('ROUTER_CONFIGURATION');\n\n/**\n * @docsNotRequired\n */\nexport const ROUTER_FORROOT_GUARD = new InjectionToken<void>('ROUTER_FORROOT_GUARD');\n\nexport const ROUTER_PROVIDERS: Provider[] = [\n  Location,\n  {provide: UrlSerializer, useClass: DefaultUrlSerializer},\n  {\n    provide: Router,\n    useFactory: setupRouter,\n    deps: [\n      ApplicationRef, UrlSerializer, ChildrenOutletContexts, Location, Injector,\n      NgModuleFactoryLoader, Compiler, ROUTES, ROUTER_CONFIGURATION,\n      [UrlHandlingStrategy, new Optional()], [RouteReuseStrategy, new Optional()]\n    ]\n  },\n  ChildrenOutletContexts,\n  {provide: ActivatedRoute, useFactory: rootRoute, deps: [Router]},\n  {provide: NgModuleFactoryLoader, useClass: SystemJsNgModuleLoader},\n  RouterPreloader,\n  NoPreloading,\n  PreloadAllModules,\n  {provide: ROUTER_CONFIGURATION, useValue: {enableTracing: false}},\n];\n\nexport function routerNgProbeToken() {\n  return new NgProbeToken('Router', Router);\n}\n\n/**\n * @usageNotes\n *\n * RouterModule can be imported multiple times: once per lazily-loaded bundle.\n * Since the router deals with a global shared resource--location, we cannot have\n * more than one router service active.\n *\n * That is why there are two ways to create the module: `RouterModule.forRoot` and\n * `RouterModule.forChild`.\n *\n * * `forRoot` creates a module that contains all the directives, the given routes, and the router\n *   service itself.\n * * `forChild` creates a module that contains all the directives and the given routes, but does not\n *   include the router service.\n *\n * When registered at the root, the module should be used as follows\n *\n * ```\n * @NgModule({\n *   imports: [RouterModule.forRoot(ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n *\n * For submodules and lazy loaded submodules the module should be used as follows:\n *\n * ```\n * @NgModule({\n *   imports: [RouterModule.forChild(ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n *\n * @description\n *\n * Adds router directives and providers.\n *\n * Managing state transitions is one of the hardest parts of building applications. This is\n * especially true on the web, where you also need to ensure that the state is reflected in the URL.\n * In addition, we often want to split applications into multiple bundles and load them on demand.\n * Doing this transparently is not trivial.\n *\n * The Angular router solves these problems. Using the router, you can declaratively specify\n * application states, manage state transitions while taking care of the URL, and load bundles on\n * demand.\n *\n * [Read this developer guide](https://angular.io/docs/ts/latest/guide/router.html) to get an\n * overview of how the router should be used.\n *\n * @publicApi\n */\n@NgModule({\n  declarations: ROUTER_DIRECTIVES,\n  exports: ROUTER_DIRECTIVES,\n  entryComponents: [EmptyOutletComponent]\n})\nexport class RouterModule {\n  // Note: We are injecting the Router so it gets created eagerly...\n  constructor(@Optional() @Inject(ROUTER_FORROOT_GUARD) guard: any, @Optional() router: Router) {}\n\n  /**\n   * Creates a module with all the router providers and directives. It also optionally sets up an\n   * application listener to perform an initial navigation.\n   *\n   * Options (see `ExtraOptions`):\n   * * `enableTracing` makes the router log all its internal events to the console.\n   * * `useHash` enables the location strategy that uses the URL fragment instead of the history\n   * API.\n   * * `initialNavigation` disables the initial navigation.\n   * * `errorHandler` provides a custom error handler.\n   * * `preloadingStrategy` configures a preloading strategy (see `PreloadAllModules`).\n   * * `onSameUrlNavigation` configures how the router handles navigation to the current URL. See\n   * `ExtraOptions` for more details.\n   * * `paramsInheritanceStrategy` defines how the router merges params, data and resolved data\n   * from parent to child routes.\n   */\n  static forRoot(routes: Routes, config?: ExtraOptions): ModuleWithProviders<RouterModule> {\n    return {\n      ngModule: RouterModule,\n      providers: [\n        ROUTER_PROVIDERS,\n        provideRoutes(routes),\n        {\n          provide: ROUTER_FORROOT_GUARD,\n          useFactory: provideForRootGuard,\n          deps: [[Router, new Optional(), new SkipSelf()]]\n        },\n        {provide: ROUTER_CONFIGURATION, useValue: config ? config : {}},\n        {\n          provide: LocationStrategy,\n          useFactory: provideLocationStrategy,\n          deps: [\n            PlatformLocation, [new Inject(APP_BASE_HREF), new Optional()], ROUTER_CONFIGURATION\n          ]\n        },\n        {\n          provide: RouterScroller,\n          useFactory: createRouterScroller,\n          deps: [Router, ViewportScroller, ROUTER_CONFIGURATION]\n        },\n        {\n          provide: PreloadingStrategy,\n          useExisting: config && config.preloadingStrategy ? config.preloadingStrategy :\n                                                             NoPreloading\n        },\n        {provide: NgProbeToken, multi: true, useFactory: routerNgProbeToken},\n        provideRouterInitializer(),\n      ],\n    };\n  }\n\n  /**\n   * Creates a module with all the router directives and a provider registering routes.\n   */\n  static forChild(routes: Routes): ModuleWithProviders<RouterModule> {\n    return {ngModule: RouterModule, providers: [provideRoutes(routes)]};\n  }\n}\n\nexport function createRouterScroller(\n    router: Router, viewportScroller: ViewportScroller, config: ExtraOptions): RouterScroller {\n  if (config.scrollOffset) {\n    viewportScroller.setOffset(config.scrollOffset);\n  }\n  return new RouterScroller(router, viewportScroller, config);\n}\n\nexport function provideLocationStrategy(\n    platformLocationStrategy: PlatformLocation, baseHref: string, options: ExtraOptions = {}) {\n  return options.useHash ? new HashLocationStrategy(platformLocationStrategy, baseHref) :\n                           new PathLocationStrategy(platformLocationStrategy, baseHref);\n}\n\nexport function provideForRootGuard(router: Router): any {\n  if (router) {\n    throw new Error(\n        `RouterModule.forRoot() called twice. Lazy loaded modules should use RouterModule.forChild() instead.`);\n  }\n  return 'guarded';\n}\n\n/**\n * @description\n *\n * Registers routes.\n *\n * @usageNotes\n * ### Example\n *\n * ```\n * @NgModule({\n *   imports: [RouterModule.forChild(ROUTES)],\n *   providers: [provideRoutes(EXTRA_ROUTES)]\n * })\n * class MyNgModule {}\n * ```\n *\n * @publicApi\n */\nexport function provideRoutes(routes: Routes): any {\n  return [\n    {provide: ANALYZE_FOR_ENTRY_COMPONENTS, multi: true, useValue: routes},\n    {provide: ROUTES, multi: true, useValue: routes},\n  ];\n}\n\n/**\n * @description\n *\n * Represents an option to configure when the initial navigation is performed.\n *\n * * 'enabled' - the initial navigation starts before the root component is created.\n * The bootstrap is blocked until the initial navigation is complete.\n * * 'disabled' - the initial navigation is not performed. The location listener is set up before\n * the root component gets created.\n * * 'legacy_enabled'- the initial navigation starts after the root component has been created.\n * The bootstrap is not blocked until the initial navigation is complete. @deprecated\n * * 'legacy_disabled'- the initial navigation is not performed. The location listener is set up\n * after @deprecated\n * the root component gets created.\n * * `true` - same as 'legacy_enabled'. @deprecated since v4\n * * `false` - same as 'legacy_disabled'. @deprecated since v4\n *\n * The 'enabled' option should be used for applications unless there is a reason to have\n * more control over when the router starts its initial navigation due to some complex\n * initialization logic. In this case, 'disabled' should be used.\n *\n * The 'legacy_enabled' and 'legacy_disabled' should not be used for new applications.\n *\n * @publicApi\n */\nexport type InitialNavigation =\n    true | false | 'enabled' | 'disabled' | 'legacy_enabled' | 'legacy_disabled';\n\n/**\n * @description\n *\n * Represents options to configure the router.\n *\n * @publicApi\n */\nexport interface ExtraOptions {\n  /**\n   * Makes the router log all its internal events to the console.\n   */\n  enableTracing?: boolean;\n\n  /**\n   * Enables the location strategy that uses the URL fragment instead of the history API.\n   */\n  useHash?: boolean;\n\n  /**\n   * Disables the initial navigation.\n   */\n  initialNavigation?: InitialNavigation;\n\n  /**\n   * A custom error handler.\n   */\n  errorHandler?: ErrorHandler;\n\n  /**\n   * Configures a preloading strategy. See `PreloadAllModules`.\n   */\n  preloadingStrategy?: any;\n\n  /**\n   * Define what the router should do if it receives a navigation request to the current URL.\n   * By default, the router will ignore this navigation. However, this prevents features such\n   * as a \"refresh\" button. Use this option to configure the behavior when navigating to the\n   * current URL. Default is 'ignore'.\n   */\n  onSameUrlNavigation?: 'reload'|'ignore';\n\n  /**\n   * Configures if the scroll position needs to be restored when navigating back.\n   *\n   * * 'disabled'--does nothing (default).\n   * * 'top'--set the scroll position to 0,0..\n   * * 'enabled'--set the scroll position