@angular/router
Version:
Angular - the routing library
149 lines (148 loc) • 16.7 kB
JavaScript
/**
*@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 * as tslib_1 from "tslib";
import { Compiler, Injectable, Injector, NgModuleFactoryLoader, NgModuleRef } from '@angular/core';
import { from, of } from 'rxjs';
import { catchError, concatMap, filter, map, mergeAll, mergeMap } from 'rxjs/operators';
import { NavigationEnd, RouteConfigLoadEnd, RouteConfigLoadStart } from './events';
import { Router } from './router';
import { RouterConfigLoader } from './router_config_loader';
/**
* @description
*
* Provides a preloading strategy.
*
* @publicApi
*/
var PreloadingStrategy = /** @class */ (function () {
function PreloadingStrategy() {
}
return PreloadingStrategy;
}());
export { PreloadingStrategy };
/**
* @description
*
* Provides a preloading strategy that preloads all modules as quickly as possible.
*
* ```
* RouteModule.forRoot(ROUTES, {preloadingStrategy: PreloadAllModules})
* ```
*
* @publicApi
*/
var PreloadAllModules = /** @class */ (function () {
function PreloadAllModules() {
}
PreloadAllModules.prototype.preload = function (route, fn) {
return fn().pipe(catchError(function () { return of(null); }));
};
return PreloadAllModules;
}());
export { PreloadAllModules };
/**
* @description
*
* Provides a preloading strategy that does not preload any modules.
*
* This strategy is enabled by default.
*
* @publicApi
*/
var NoPreloading = /** @class */ (function () {
function NoPreloading() {
}
NoPreloading.prototype.preload = function (route, fn) { return of(null); };
return NoPreloading;
}());
export { 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.
*
* @publicApi
*/
var RouterPreloader = /** @class */ (function () {
function RouterPreloader(router, moduleLoader, compiler, injector, preloadingStrategy) {
this.router = router;
this.injector = injector;
this.preloadingStrategy = preloadingStrategy;
var onStartLoad = function (r) { return router.triggerEvent(new RouteConfigLoadStart(r)); };
var onEndLoad = function (r) { return router.triggerEvent(new RouteConfigLoadEnd(r)); };
this.loader = new RouterConfigLoader(moduleLoader, compiler, onStartLoad, onEndLoad);
}
RouterPreloader.prototype.setUpPreloading = function () {
var _this = this;
this.subscription =
this.router.events
.pipe(filter(function (e) { return e instanceof NavigationEnd; }), concatMap(function () { return _this.preload(); }))
.subscribe(function () { });
};
RouterPreloader.prototype.preload = function () {
var ngModule = this.injector.get(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.
RouterPreloader.prototype.ngOnDestroy = function () { this.subscription.unsubscribe(); };
RouterPreloader.prototype.processRoutes = function (ngModule, routes) {
var e_1, _a;
var res = [];
try {
for (var routes_1 = tslib_1.__values(routes), routes_1_1 = routes_1.next(); !routes_1_1.done; routes_1_1 = routes_1.next()) {
var route = routes_1_1.value;
// we already have the config loaded, just recurse
if (route.loadChildren && !route.canLoad && route._loadedConfig) {
var 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));
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);
}
finally { if (e_1) throw e_1.error; }
}
return from(res).pipe(mergeAll(), map(function (_) { return void 0; }));
};
RouterPreloader.prototype.preloadConfig = function (ngModule, route) {
var _this = this;
return this.preloadingStrategy.preload(route, function () {
var loaded$ = _this.loader.load(ngModule.injector, route);
return loaded$.pipe(mergeMap(function (config) {
route._loadedConfig = config;
return _this.processRoutes(config.module, config.routes);
}));
});
};
RouterPreloader = tslib_1.__decorate([
Injectable(),
tslib_1.__metadata("design:paramtypes", [Router, NgModuleFactoryLoader, Compiler,
Injector, PreloadingStrategy])
], RouterPreloader);
return RouterPreloader;
}());
export { RouterPreloader };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router_preloader.js","sourceRoot":"","sources":["../../../../../../../../../packages/router/src/router_preloader.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 {Compiler, Injectable, Injector, NgModuleFactoryLoader, NgModuleRef, OnDestroy} from '@angular/core';\nimport {Observable, Subscription, from, of } from 'rxjs';\nimport {catchError, concatMap, filter, map, mergeAll, mergeMap} from 'rxjs/operators';\n\nimport {LoadedRouterConfig, Route, Routes} from './config';\nimport {Event, NavigationEnd, RouteConfigLoadEnd, RouteConfigLoadStart} from './events';\nimport {Router} from './router';\nimport {RouterConfigLoader} from './router_config_loader';\n\n\n/**\n * @description\n *\n * Provides a preloading strategy.\n *\n * @publicApi\n */\nexport abstract class PreloadingStrategy {\n  abstract preload(route: Route, fn: () => Observable<any>): Observable<any>;\n}\n\n/**\n * @description\n *\n * Provides a preloading strategy that preloads all modules as quickly as possible.\n *\n * ```\n * RouteModule.forRoot(ROUTES, {preloadingStrategy: PreloadAllModules})\n * ```\n *\n * @publicApi\n */\nexport class PreloadAllModules implements PreloadingStrategy {\n  preload(route: Route, fn: () => Observable<any>): Observable<any> {\n    return fn().pipe(catchError(() => of (null)));\n  }\n}\n\n/**\n * @description\n *\n * Provides a preloading strategy that does not preload any modules.\n *\n * This strategy is enabled by default.\n *\n * @publicApi\n */\nexport class NoPreloading implements PreloadingStrategy {\n  preload(route: Route, fn: () => Observable<any>): Observable<any> { return of (null); }\n}\n\n/**\n * The preloader optimistically loads all router configurations to\n * make navigations into lazily-loaded sections of the application faster.\n *\n * The preloader runs in the background. When the router bootstraps, the preloader\n * starts listening to all navigation events. After every such event, the preloader\n * will check if any configurations can be loaded lazily.\n *\n * If a route is protected by `canLoad` guards, the preloaded will not load it.\n *\n * @publicApi\n */\n@Injectable()\nexport class RouterPreloader implements OnDestroy {\n  private loader: RouterConfigLoader;\n  // TODO(issue/24571): remove '!'.\n  private subscription !: Subscription;\n\n  constructor(\n      private router: Router, moduleLoader: NgModuleFactoryLoader, compiler: Compiler,\n      private injector: Injector, private preloadingStrategy: PreloadingStrategy) {\n    const onStartLoad = (r: Route) => router.triggerEvent(new RouteConfigLoadStart(r));\n    const onEndLoad = (r: Route) => router.triggerEvent(new RouteConfigLoadEnd(r));\n\n    this.loader = new RouterConfigLoader(moduleLoader, compiler, onStartLoad, onEndLoad);\n  }\n\n  setUpPreloading(): void {\n    this.subscription =\n        this.router.events\n            .pipe(filter((e: Event) => e instanceof NavigationEnd), concatMap(() => this.preload()))\n            .subscribe(() => {});\n  }\n\n  preload(): Observable<any> {\n    const ngModule = this.injector.get(NgModuleRef);\n    return this.processRoutes(ngModule, this.router.config);\n  }\n\n  // TODO(jasonaden): This class relies on code external to the class to call setUpPreloading. If\n  // this hasn't been done, ngOnDestroy will fail as this.subscription will be undefined. This\n  // should be refactored.\n  ngOnDestroy(): void { this.subscription.unsubscribe(); }\n\n  private processRoutes(ngModule: NgModuleRef<any>, routes: Routes): Observable<void> {\n    const res: Observable<any>[] = [];\n    for (const route of routes) {\n      // we already have the config loaded, just recurse\n      if (route.loadChildren && !route.canLoad && route._loadedConfig) {\n        const childConfig = route._loadedConfig;\n        res.push(this.processRoutes(childConfig.module, childConfig.routes));\n\n        // no config loaded, fetch the config\n      } else if (route.loadChildren && !route.canLoad) {\n        res.push(this.preloadConfig(ngModule, route));\n\n        // recurse into children\n      } else if (route.children) {\n        res.push(this.processRoutes(ngModule, route.children));\n      }\n    }\n    return from(res).pipe(mergeAll(), map((_) => void 0));\n  }\n\n  private preloadConfig(ngModule: NgModuleRef<any>, route: Route): Observable<void> {\n    return this.preloadingStrategy.preload(route, () => {\n      const loaded$ = this.loader.load(ngModule.injector, route);\n      return loaded$.pipe(mergeMap((config: LoadedRouterConfig) => {\n        route._loadedConfig = config;\n        return this.processRoutes(config.module, config.routes);\n      }));\n    });\n  }\n}\n"]}