/** * @fileoverview added by tsickle * Generated from: packages/router/src/interfaces.ts * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,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 */ /** * \@description * * Interface that a class can implement to be a guard deciding if a route can be activated. * If all guards return `true`, navigation will continue. If any guard returns `false`, * navigation will be cancelled. If any guard returns a `UrlTree`, current navigation will * be cancelled and a new navigation will be kicked off to the `UrlTree` returned from the * guard. * * ``` * class UserToken {} * class Permissions { * canActivate(user: UserToken, id: string): boolean { * return true; * } * } * * \@Injectable() * class CanActivateTeam implements CanActivate { * constructor(private permissions: Permissions, private currentUser: UserToken) {} * * canActivate( * route: ActivatedRouteSnapshot, * state: RouterStateSnapshot * ): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree { * return this.permissions.canActivate(this.currentUser, route.params.id); * } * } * * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'team/:id', * component: TeamComponent, * canActivate: [CanActivateTeam] * } * ]) * ], * providers: [CanActivateTeam, UserToken, Permissions] * }) * class AppModule {} * ``` * * You can alternatively provide a function with the `canActivate` signature: * * ``` * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'team/:id', * component: TeamComponent, * canActivate: ['canActivateTeam'] * } * ]) * ], * providers: [ * { * provide: 'canActivateTeam', * useValue: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => true * } * ] * }) * class AppModule {} * ``` * * \@publicApi * @record */ export function CanActivate() { } if (false) { /** * @param {?} route * @param {?} state * @return {?} */ CanActivate.prototype.canActivate = function (route, state) { }; } /** * \@description * * Interface that a class can implement to be a guard deciding if a child route can be activated. * If all guards return `true`, navigation will continue. If any guard returns `false`, * navigation will be cancelled. If any guard returns a `UrlTree`, current navigation will * be cancelled and a new navigation will be kicked off to the `UrlTree` returned from the * guard. * * ``` * class UserToken {} * class Permissions { * canActivate(user: UserToken, id: string): boolean { * return true; * } * } * * \@Injectable() * class CanActivateTeam implements CanActivateChild { * constructor(private permissions: Permissions, private currentUser: UserToken) {} * * canActivateChild( * route: ActivatedRouteSnapshot, * state: RouterStateSnapshot * ): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree { * return this.permissions.canActivate(this.currentUser, route.params.id); * } * } * * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'root', * canActivateChild: [CanActivateTeam], * children: [ * { * path: 'team/:id', * component: TeamComponent * } * ] * } * ]) * ], * providers: [CanActivateTeam, UserToken, Permissions] * }) * class AppModule {} * ``` * * You can alternatively provide a function with the `canActivateChild` signature: * * ``` * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'root', * canActivateChild: ['canActivateTeam'], * children: [ * { * path: 'team/:id', * component: TeamComponent * } * ] * } * ]) * ], * providers: [ * { * provide: 'canActivateTeam', * useValue: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => true * } * ] * }) * class AppModule {} * ``` * * \@publicApi * @record */ export function CanActivateChild() { } if (false) { /** * @param {?} childRoute * @param {?} state * @return {?} */ CanActivateChild.prototype.canActivateChild = function (childRoute, state) { }; } /** * \@description * * Interface that a class can implement to be a guard deciding if a route can be deactivated. * If all guards return `true`, navigation will continue. If any guard returns `false`, * navigation will be cancelled. If any guard returns a `UrlTree`, current navigation will * be cancelled and a new navigation will be kicked off to the `UrlTree` returned from the * guard. * * ``` * class UserToken {} * class Permissions { * canDeactivate(user: UserToken, id: string): boolean { * return true; * } * } * * \@Injectable() * class CanDeactivateTeam implements CanDeactivate<TeamComponent> { * constructor(private permissions: Permissions, private currentUser: UserToken) {} * * canDeactivate( * component: TeamComponent, * currentRoute: ActivatedRouteSnapshot, * currentState: RouterStateSnapshot, * nextState: RouterStateSnapshot * ): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree { * return this.permissions.canDeactivate(this.currentUser, route.params.id); * } * } * * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'team/:id', * component: TeamComponent, * canDeactivate: [CanDeactivateTeam] * } * ]) * ], * providers: [CanDeactivateTeam, UserToken, Permissions] * }) * class AppModule {} * ``` * * You can alternatively provide a function with the `canDeactivate` signature: * * ``` * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'team/:id', * component: TeamComponent, * canDeactivate: ['canDeactivateTeam'] * } * ]) * ], * providers: [ * { * provide: 'canDeactivateTeam', * useValue: (component: TeamComponent, currentRoute: ActivatedRouteSnapshot, currentState: * RouterStateSnapshot, nextState: RouterStateSnapshot) => true * } * ] * }) * class AppModule {} * ``` * * \@publicApi * @record * @template T */ export function CanDeactivate() { } if (false) { /** * @param {?} component * @param {?} currentRoute * @param {?} currentState * @param {?=} nextState * @return {?} */ CanDeactivate.prototype.canDeactivate = function (component, currentRoute, currentState, nextState) { }; } /** * \@description * * Interface that classes can implement to be a data provider. * A data provider class can be used with the router to resolve data during navigation. * The interface defines a `resolve()` method that will be invoked when the navigation starts. * The router will then wait for the data to be resolved before the route is finally activated. * * ``` * \@Injectable({ providedIn: 'root' }) * export class HeroResolver implements Resolve<Hero> { * constructor(private service: HeroService) {} * * resolve( * route: ActivatedRouteSnapshot, * state: RouterStateSnapshot * ): Observable<any>|Promise<any>|any { * return this.service.getHero(route.paramMap.get('id')); * } * } * * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'detail/:id', * component: HeroDetailComponent, * resolve: { * hero: HeroResolver * } * } * ]) * ], * exports: [RouterModule] * }) * export class AppRoutingModule {} * ``` * * You can alternatively provide a function with the `resolve` signature: * * ``` * export const myHero: Hero = { * // ... * } * * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'detail/:id', * component: HeroComponent, * resolve: { * hero: 'heroResolver' * } * } * ]) * ], * providers: [ * { * provide: 'heroResolver', * useValue: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => myHero * } * ] * }) * export class AppModule {} * ``` * * \@publicApi * @record * @template T */ export function Resolve() { } if (false) { /** * @param {?} route * @param {?} state * @return {?} */ Resolve.prototype.resolve = function (route, state) { }; } /** * \@description * * Interface that a class can implement to be a guard deciding if children can be loaded. * * ``` * class UserToken {} * class Permissions { * canLoadChildren(user: UserToken, id: string, segments: UrlSegment[]): boolean { * return true; * } * } * * \@Injectable() * class CanLoadTeamSection implements CanLoad { * constructor(private permissions: Permissions, private currentUser: UserToken) {} * * canLoad(route: Route, segments: UrlSegment[]): Observable<boolean>|Promise<boolean>|boolean { * return this.permissions.canLoadChildren(this.currentUser, route, segments); * } * } * * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'team/:id', * component: TeamComponent, * loadChildren: 'team.js', * canLoad: [CanLoadTeamSection] * } * ]) * ], * providers: [CanLoadTeamSection, UserToken, Permissions] * }) * class AppModule {} * ``` * * You can alternatively provide a function with the `canLoad` signature: * * ``` * \@NgModule({ * imports: [ * RouterModule.forRoot([ * { * path: 'team/:id', * component: TeamComponent, * loadChildren: 'team.js', * canLoad: ['canLoadTeamSection'] * } * ]) * ], * providers: [ * { * provide: 'canLoadTeamSection', * useValue: (route: Route, segments: UrlSegment[]) => true * } * ] * }) * class AppModule {} * ``` * * \@publicApi * @record */ export function CanLoad() { } if (false) { /** * @param {?} route * @param {?} segments * @return {?} */ CanLoad.prototype.canLoad = function (route, segments) { }; } //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../packages/router/src/interfaces.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,iCAGC;;;;;;;IAFC,gEACyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqF3E,sCAGC;;;;;;;IAFC,+EACyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8E3E,mCAKC;;;;;;;;;IAJC,wGAGa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6Ef,6BAEC;;;;;;;IADC,wDAA+F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEjG,6BAEC;;;;;;;IADC,2DAA4F","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 {Observable} from 'rxjs';\n\nimport {Route} from './config';\nimport {ActivatedRouteSnapshot, RouterStateSnapshot} from './router_state';\nimport {UrlSegment, UrlTree} from './url_tree';\n\n\n/**\n * @description\n *\n * Interface that a class can implement to be a guard deciding if a route can be activated.\n * If all guards return `true`, navigation will continue. If any guard returns `false`,\n * navigation will be cancelled. If any guard returns a `UrlTree`, current navigation will\n * be cancelled and a new navigation will be kicked off to the `UrlTree` returned from the\n * guard.\n *\n * ```\n * class UserToken {}\n * class Permissions {\n *   canActivate(user: UserToken, id: string): boolean {\n *     return true;\n *   }\n * }\n *\n * @Injectable()\n * class CanActivateTeam implements CanActivate {\n *   constructor(private permissions: Permissions, private currentUser: UserToken) {}\n *\n *   canActivate(\n *     route: ActivatedRouteSnapshot,\n *     state: RouterStateSnapshot\n *   ): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree {\n *     return this.permissions.canActivate(this.currentUser, route.params.id);\n *   }\n * }\n *\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'team/:id',\n *         component: TeamComponent,\n *         canActivate: [CanActivateTeam]\n *       }\n *     ])\n *   ],\n *   providers: [CanActivateTeam, UserToken, Permissions]\n * })\n * class AppModule {}\n * ```\n *\n * You can alternatively provide a function with the `canActivate` signature:\n *\n * ```\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'team/:id',\n *         component: TeamComponent,\n *         canActivate: ['canActivateTeam']\n *       }\n *     ])\n *   ],\n *   providers: [\n *     {\n *       provide: 'canActivateTeam',\n *       useValue: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => true\n *     }\n *   ]\n * })\n * class AppModule {}\n * ```\n *\n * @publicApi\n */\nexport interface CanActivate {\n  canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot):\n      Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree;\n}\n\nexport type CanActivateFn = (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) =>\n    Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree;\n\n/**\n * @description\n *\n * Interface that a class can implement to be a guard deciding if a child route can be activated.\n * If all guards return `true`, navigation will continue. If any guard returns `false`,\n * navigation will be cancelled. If any guard returns a `UrlTree`, current navigation will\n * be cancelled and a new navigation will be kicked off to the `UrlTree` returned from the\n * guard.\n *\n * ```\n * class UserToken {}\n * class Permissions {\n *   canActivate(user: UserToken, id: string): boolean {\n *     return true;\n *   }\n * }\n *\n * @Injectable()\n * class CanActivateTeam implements CanActivateChild {\n *   constructor(private permissions: Permissions, private currentUser: UserToken) {}\n *\n *   canActivateChild(\n *     route: ActivatedRouteSnapshot,\n *     state: RouterStateSnapshot\n *   ): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree {\n *     return this.permissions.canActivate(this.currentUser, route.params.id);\n *   }\n * }\n *\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'root',\n *         canActivateChild: [CanActivateTeam],\n *         children: [\n *           {\n *              path: 'team/:id',\n *              component: TeamComponent\n *           }\n *         ]\n *       }\n *     ])\n *   ],\n *   providers: [CanActivateTeam, UserToken, Permissions]\n * })\n * class AppModule {}\n * ```\n *\n * You can alternatively provide a function with the `canActivateChild` signature:\n *\n * ```\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'root',\n *         canActivateChild: ['canActivateTeam'],\n *         children: [\n *           {\n *             path: 'team/:id',\n *             component: TeamComponent\n *           }\n *         ]\n *       }\n *     ])\n *   ],\n *   providers: [\n *     {\n *       provide: 'canActivateTeam',\n *       useValue: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => true\n *     }\n *   ]\n * })\n * class AppModule {}\n * ```\n *\n * @publicApi\n */\nexport interface CanActivateChild {\n  canActivateChild(childRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot):\n      Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree;\n}\n\nexport type CanActivateChildFn = (childRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot) =>\n    Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree;\n\n/**\n * @description\n *\n * Interface that a class can implement to be a guard deciding if a route can be deactivated.\n * If all guards return `true`, navigation will continue. If any guard returns `false`,\n * navigation will be cancelled. If any guard returns a `UrlTree`, current navigation will\n * be cancelled and a new navigation will be kicked off to the `UrlTree` returned from the\n * guard.\n *\n * ```\n * class UserToken {}\n * class Permissions {\n *   canDeactivate(user: UserToken, id: string): boolean {\n *     return true;\n *   }\n * }\n *\n * @Injectable()\n * class CanDeactivateTeam implements CanDeactivate<TeamComponent> {\n *   constructor(private permissions: Permissions, private currentUser: UserToken) {}\n *\n *   canDeactivate(\n *     component: TeamComponent,\n *     currentRoute: ActivatedRouteSnapshot,\n *     currentState: RouterStateSnapshot,\n *     nextState: RouterStateSnapshot\n *   ): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree {\n *     return this.permissions.canDeactivate(this.currentUser, route.params.id);\n *   }\n * }\n *\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'team/:id',\n *         component: TeamComponent,\n *         canDeactivate: [CanDeactivateTeam]\n *       }\n *     ])\n *   ],\n *   providers: [CanDeactivateTeam, UserToken, Permissions]\n * })\n * class AppModule {}\n * ```\n *\n * You can alternatively provide a function with the `canDeactivate` signature:\n *\n * ```\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'team/:id',\n *         component: TeamComponent,\n *         canDeactivate: ['canDeactivateTeam']\n *       }\n *     ])\n *   ],\n *   providers: [\n *     {\n *       provide: 'canDeactivateTeam',\n *       useValue: (component: TeamComponent, currentRoute: ActivatedRouteSnapshot, currentState:\n * RouterStateSnapshot, nextState: RouterStateSnapshot) => true\n *     }\n *   ]\n * })\n * class AppModule {}\n * ```\n *\n * @publicApi\n */\nexport interface CanDeactivate<T> {\n  canDeactivate(\n      component: T, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot,\n      nextState?: RouterStateSnapshot): Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean\n      |UrlTree;\n}\n\nexport type CanDeactivateFn<T> =\n    (component: T, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot,\n     nextState?: RouterStateSnapshot) =>\n        Observable<boolean|UrlTree>|Promise<boolean|UrlTree>|boolean|UrlTree;\n\n/**\n * @description\n *\n * Interface that classes can implement to be a data provider.\n * A data provider class can be used with the router to resolve data during navigation.\n * The interface defines a `resolve()` method that will be invoked when the navigation starts.\n * The router will then wait for the data to be resolved before the route is finally activated.\n *\n * ```\n * @Injectable({ providedIn: 'root' })\n * export class HeroResolver implements Resolve<Hero> {\n *   constructor(private service: HeroService) {}\n *\n *   resolve(\n *     route: ActivatedRouteSnapshot,\n *     state: RouterStateSnapshot\n *   ): Observable<any>|Promise<any>|any {\n *     return this.service.getHero(route.paramMap.get('id'));\n *   }\n * }\n *\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'detail/:id',\n *         component: HeroDetailComponent,\n *         resolve: {\n *           hero: HeroResolver\n *         }\n *       }\n *     ])\n *   ],\n *   exports: [RouterModule]\n * })\n * export class AppRoutingModule {}\n * ```\n *\n * You can alternatively provide a function with the `resolve` signature:\n *\n * ```\n * export const myHero: Hero = {\n *   // ...\n * }\n *\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'detail/:id',\n *         component: HeroComponent,\n *         resolve: {\n *           hero: 'heroResolver'\n *         }\n *       }\n *     ])\n *   ],\n *   providers: [\n *     {\n *       provide: 'heroResolver',\n *       useValue: (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => myHero\n *     }\n *   ]\n * })\n * export class AppModule {}\n * ```\n *\n * @publicApi\n */\nexport interface Resolve<T> {\n  resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<T>|Promise<T>|T;\n}\n\n\n/**\n * @description\n *\n * Interface that a class can implement to be a guard deciding if children can be loaded.\n *\n * ```\n * class UserToken {}\n * class Permissions {\n *   canLoadChildren(user: UserToken, id: string, segments: UrlSegment[]): boolean {\n *     return true;\n *   }\n * }\n *\n * @Injectable()\n * class CanLoadTeamSection implements CanLoad {\n *   constructor(private permissions: Permissions, private currentUser: UserToken) {}\n *\n *   canLoad(route: Route, segments: UrlSegment[]): Observable<boolean>|Promise<boolean>|boolean {\n *     return this.permissions.canLoadChildren(this.currentUser, route, segments);\n *   }\n * }\n *\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'team/:id',\n *         component: TeamComponent,\n *         loadChildren: 'team.js',\n *         canLoad: [CanLoadTeamSection]\n *       }\n *     ])\n *   ],\n *   providers: [CanLoadTeamSection, UserToken, Permissions]\n * })\n * class AppModule {}\n * ```\n *\n * You can alternatively provide a function with the `canLoad` signature:\n *\n * ```\n * @NgModule({\n *   imports: [\n *     RouterModule.forRoot([\n *       {\n *         path: 'team/:id',\n *         component: TeamComponent,\n *         loadChildren: 'team.js',\n *         canLoad: ['canLoadTeamSection']\n *       }\n *     ])\n *   ],\n *   providers: [\n *     {\n *       provide: 'canLoadTeamSection',\n *       useValue: (route: Route, segments: UrlSegment[]) => true\n *     }\n *   ]\n * })\n * class AppModule {}\n * ```\n *\n * @publicApi\n */\nexport interface CanLoad {\n  canLoad(route: Route, segments: UrlSegment[]): Observable<boolean>|Promise<boolean>|boolean;\n}\n\nexport type CanLoadFn = (route: Route, segments: UrlSegment[]) =>\n    Observable<boolean>|Promise<boolean>|boolean;\n"]}