@bespunky/angular-zen
Version:
The Angular tools you always wished were there.
186 lines • 35 kB
JavaScript
import { from, of } from 'rxjs';
import { concatAll, filter, finalize, takeUntil, toArray } from 'rxjs/operators';
import { Directive, Injectable } from '@angular/core';
import { Router, ActivatedRoute, ActivationEnd, ActivationStart, ChildActivationEnd, ChildActivationStart, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RoutesRecognized, Scroll } from '@angular/router';
import { Destroyable } from '@bespunky/angular-zen/core';
import { RouterOutletComponentBus } from '../outlet/router-outlet-component-bus.service';
import * as i0 from "@angular/core";
import * as i1 from "@angular/router";
import * as i2 from "../outlet/router-outlet-component-bus.service";
/**
* Hard-codes event names as strings.
* When AOT compilation is run and constructor names change, the dispatcher will still be able to get a hold
* of the correct event name using this map.
*/
const EventMap = {
[NavigationStart.prototype.constructor.name]: 'NavigationStart',
[RouteConfigLoadStart.prototype.constructor.name]: 'RouteConfigLoadStart',
[RouteConfigLoadEnd.prototype.constructor.name]: 'RouteConfigLoadEnd',
[RoutesRecognized.prototype.constructor.name]: 'RoutesRecognized',
[GuardsCheckStart.prototype.constructor.name]: 'GuardsCheckStart',
[ChildActivationStart.prototype.constructor.name]: 'ChildActivationStart',
[ActivationStart.prototype.constructor.name]: 'ActivationStart',
[GuardsCheckEnd.prototype.constructor.name]: 'GuardsCheckEnd',
[ResolveStart.prototype.constructor.name]: 'ResolveStart',
[ResolveEnd.prototype.constructor.name]: 'ResolveEnd',
[ChildActivationEnd.prototype.constructor.name]: 'ChildActivationEnd',
[ActivationEnd.prototype.constructor.name]: 'ActivationEnd',
[NavigationEnd.prototype.constructor.name]: 'NavigationEnd',
[NavigationCancel.prototype.constructor.name]: 'NavigationCancel',
[NavigationError.prototype.constructor.name]: 'NavigationError',
[Scroll.prototype.constructor.name]: 'Scroll'
};
/**
* The prefix of the id generated for zone macro tasks when calling `RouteAware.resolveInMacroTask()`.
*
* Generated ids will confrom to a `{prefix}-{random number}` format.
*/
export const ResolverMacroTaskIdPrefix = 'route-aware-resolver';
/**
* Provides functionality for extending class to easily work with routes and process changes.
*
* @export
* @abstract
* @class RouteAware
* @extends {Destroyable}
*/
// eslint-disable-next-line @angular-eslint/directive-class-suffix
export class RouteAware extends Destroyable {
/**
* Creates an instance of RouteAware.
*
* @param {Router} router The instance of Angular's router service.
* @param {ActivatedRoute} route The instance of Angular's active route service.
* @param {RouterOutletComponentBus} [componentBus] (Optional) The component bus for router-x functionality.
* Provide this when you want your route-aware service to have access to the instance(s) of the activated component(s).
*/
constructor(router, route, componentBus) {
super();
this.router = router;
this.route = route;
this.componentBus = componentBus;
// TODO: Scan class and only subscribe if handlers were defined
this.subscribe(this.router.events, this.dispatchRouterEvent.bind(this));
}
/**
* Checks if a handler method for the specific event type exists on the service and calls it.
* Handler methods should comply with `onEventType` naming (lowercase 'on', first-upper event type).
*
* @private
* @param {Event} event The event data received from the router.
*/
dispatchRouterEvent(event) {
// AOT compilation changes class names, causing the dispacher to look for a handler methods with
// wrong names (e.g. `onJ`). The EventMap is used to restore the original names.
const typeName = event.constructor.name;
const handlerName = `on${EventMap[typeName]}`;
const handle = this[handlerName];
if (handle)
handle.call(this, event);
}
/**
* Creates an observable that emits only the specified router events and is automatically destroyed when the service/component is destroyed.
*
* @protected
* @template TEvent The type of router event to emit.
* @param {Type<TEvent>} eventType The type of router event to emit.
* @param {boolean} [autoUnsubscribe=true] (Optional) `true` to make the observable complete when the service/component is destroyed; otherwise `false`. Default is `true`.
* @returns {Observable<TEvent>}
*/
observeRouterEvent(eventType, autoUnsubscribe = true) {
let observable = this.router.events;
if (autoUnsubscribe)
observable = observable.pipe(takeUntil(this.destroyed));
return observable.pipe(filter(event => event.constructor === eventType));
}
/**
* Recoursively runs a processing function on the route and its children.
* Scan is done from parent to child, meaning the parent is the first to process.
*
* @protected
* @param {ActivatedRouteSnapshot} route The top route on which to apply the processing function.
* @param {(route: ActivatedRouteSnapshot, component: any) => boolean | void} process The function to run on the route and its children. The function receives a `route` argument which reflects the route being processed,
* and a `component` argument which reflects the component that was loaded for the route's outlet.
* If the corresponding outlet wasn't marked with the `publishComponent` directive, the `component` argument will be null.
*
* Returning `true` from the process function is equal to saying 'work has completed' and will stop propogation to the route's children.
* @param {number} [levels=-1] (Optional) The number of levels (excluding the parent) to dive deeper into the route tree.
* A value of 1 for example, will process the route and its first-level children only. By default, scans all levels of the route tree.
*/
deepScanRoute(route, process, levels = -1) {
// Make sure the caller wants scan to proceed, then make sure level limit wasn't reached.
const processingConcluded = process(route, this.componentBus?.instance(route.outlet));
// Negative values will scan all, positives will scan until reaching zero.
const shouldScanChildren = !processingConcluded && levels !== 0;
if (shouldScanChildren && route.children)
route.children.forEach(childRoute => this.deepScanRoute(childRoute, process, levels - 1));
}
/**
* Creates an observable that runs all the specified resolvers and concats their results as an array.
* The resolvers will be passed with the instance of the component for the currently activated route.
*
* @protected
* @param {(Resolver | Resolver[])} resolvers The resolver(s) to concat.
* @param {...any[]} resolverArgs (Optional) Any arguments to pass into the resolvers in addition to the component.
* @returns {Observable<any[]>} An array with the concatenated results of the resolvers.
*/
resolve(resolvers, ...resolverArgs) {
if (!resolvers)
return of([]);
// Cast array
if (!Array.isArray(resolvers))
resolvers = [resolvers];
// Run resolvers to create observable tasks
const observables = resolvers.map(resolve => resolve(this.activatedRouteComponent, ...resolverArgs));
// Run tasks and output their returned data as an array
return from(observables).pipe(concatAll(), toArray());
}
/**
* Creates an observable that runs all the specified resolvers and concats their results as an array.
* The resolvers will be passed with the instance of the component for the currently activated route.
*
* **Angular Universal:**
* In SSR, the server doesn't wait for async code to complete. The result is scrapers and search engines receiving a page without resolved data,
* which is bad in case you need them to read some resolved metadata tags for example.
*
* Using `Zone` directly, this method creates a macro task and completes it when resolves are done or have errored.
* This makes the server block and wait until everything is resolved or errors before returning the rendered page.
*
* > *ℹ Make sure your resolves and process function are fast enough so that the server won't hang too much trying to render.*
*
* @see https://stackoverflow.com/a/50065783/4371525 for the discussion.
*
* @see {ResolverMacroTaskIdPrefix} if you need to identify the created macro task in your code.
*
* @protected
* @param {(Resolver | Resolver[])} resolvers The resolver(s) to concat.
* @param {...any[]} resolverArgs (Optional) Any arguments to pass into the resolvers in addition to the component.
*/
resolveInMacroTask(resolvers, ...resolverArgs) {
// eslint-disable-next-line @typescript-eslint/no-empty-function
const macroTask = Zone.current.scheduleMacroTask(`${ResolverMacroTaskIdPrefix}-${Math.random()}`, () => { }, {}, () => { }, () => { });
return this.resolve(resolvers, ...resolverArgs)
// Signal end of macro task on completion or error and allow server to return
.pipe(finalize(() => macroTask.invoke()));
}
/**
* The instance of the component created for the currently activated route.
* If no component bus was supplied at construction time, this will be `undefined`.
*
* @readonly
* @protected
* @type {(any | null)}
*/
get activatedRouteComponent() {
return this.componentBus?.instance(this.route.outlet);
}
}
RouteAware.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: RouteAware, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.RouterOutletComponentBus }], target: i0.ɵɵFactoryTarget.Directive });
RouteAware.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: RouteAware, usesInheritance: true, ngImport: i0 });
RouteAware.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: RouteAware });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: RouteAware, decorators: [{
type: Directive
}, {
type: Injectable
}], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.RouterOutletComponentBus }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-aware.service.js","sourceRoot":"","sources":["../../../../../../libs/angular-zen/router-x/src/services/route-aware.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiC,EAAE,EAAU,MAAM,MAAM,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACjF,OAAO,EAAE,SAAS,EAAQ,UAAU,EAAsB,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,cAAc,EAAiC,aAAa,EAAE,eAAe,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAErW,OAAO,EAAE,WAAW,EAAe,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;;;;AAIzF;;;;GAIG;AACH,MAAM,QAAQ,GAAG;IACb,CAAC,eAAe,CAAM,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,iBAAiB;IACpE,CAAC,oBAAoB,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,sBAAsB;IACzE,CAAC,kBAAkB,CAAG,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,oBAAoB;IACvE,CAAC,gBAAgB,CAAK,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,kBAAkB;IACrE,CAAC,gBAAgB,CAAK,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,kBAAkB;IACrE,CAAC,oBAAoB,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,sBAAsB;IACzE,CAAC,eAAe,CAAM,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,iBAAiB;IACpE,CAAC,cAAc,CAAO,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,gBAAgB;IACnE,CAAC,YAAY,CAAS,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,cAAc;IACjE,CAAC,UAAU,CAAW,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,YAAY;IAC/D,CAAC,kBAAkB,CAAG,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,oBAAoB;IACvE,CAAC,aAAa,CAAQ,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,eAAe;IAClE,CAAC,aAAa,CAAQ,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,eAAe;IAClE,CAAC,gBAAgB,CAAK,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,kBAAkB;IACrE,CAAC,eAAe,CAAM,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,iBAAiB;IACpE,CAAC,MAAM,CAAe,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,QAAQ;CAC9D,CAAC;AAKF;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAEhE;;;;;;;GAOG;AAGH,kEAAkE;AAClE,MAAM,OAAgB,UAAW,SAAQ,WAAW;IAEhD;;;;;;;OAOG;IACH,YACc,MAAqB,EACrB,KAA6B,EAC7B,YAAuC;QAGjD,KAAK,EAAE,CAAC;QALE,WAAM,GAAN,MAAM,CAAe;QACrB,UAAK,GAAL,KAAK,CAAwB;QAC7B,iBAAY,GAAZ,YAAY,CAA2B;QAKjD,+DAA+D;QAC/D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;;OAMG;IACK,mBAAmB,CAAC,KAAY;QAEpC,gGAAgG;QAChG,gFAAgF;QAChF,MAAM,QAAQ,GAAM,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;QAC3C,MAAM,WAAW,GAAG,KAAK,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAS,IAAY,CAAC,WAAW,CAAC,CAAC;QAE/C,IAAI,MAAM;YAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;OAQG;IACO,kBAAkB,CAAuB,SAAuB,EAAE,kBAA2B,IAAI;QAEvG,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAEpC,IAAI,eAAe;YAAE,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAE7E,OAAO,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC,CAAuB,CAAC;IACnG,CAAC;IAkCD;;;;;;;;;;;;;OAaG;IACO,aAAa,CAAC,KAA6B,EAAE,OAA0E,EAAE,SAAiB,CAAC,CAAC;QAElJ,yFAAyF;QACzF,MAAM,mBAAmB,GAAG,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QACtF,0EAA0E;QAC1E,MAAM,kBAAkB,GAAI,CAAC,mBAAmB,IAAI,MAAM,KAAK,CAAC,CAAC;QAEjE,IAAI,kBAAkB,IAAI,KAAK,CAAC,QAAQ;YAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IACxI,CAAC;IAED;;;;;;;;OAQG;IACO,OAAO,CAAC,SAAgC,EAAE,GAAG,YAAmB;QAEtE,IAAI,CAAC,SAAS;YAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;QAE9B,aAAa;QACb,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;YAAE,SAAS,GAAG,CAAC,SAAS,CAAC,CAAC;QAEvD,2CAA2C;QAC3C,MAAM,WAAW,GAAG,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC;QAErG,uDAAuD;QACvD,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACO,kBAAkB,CAAC,SAAgC,EAAE,GAAG,YAAmB;QAEjF,gEAAgE;QAChE,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,yBAAyB,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QAEvI,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,YAAY,CAAC;YAC3C,6EAA6E;aAC5E,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAC3C,CAAC;IACN,CAAC;IAED;;;;;;;OAOG;IACH,IAAc,uBAAuB;QAEjC,OAAO,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1D,CAAC;;wGApLiB,UAAU;4FAAV,UAAU;4GAAV,UAAU;4FAAV,UAAU;kBAH/B,SAAS;;kBACT,UAAU","sourcesContent":["import { from, InteropObservable, Observable, of         } from 'rxjs';\nimport { concatAll, filter, finalize, takeUntil, toArray } from 'rxjs/operators';\nimport { Directive, Type, Injectable                     } from '@angular/core';\nimport { Router, ActivatedRoute, ActivatedRouteSnapshot, Event, ActivationEnd, ActivationStart, ChildActivationEnd, ChildActivationStart, GuardsCheckEnd, GuardsCheckStart, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ResolveEnd, ResolveStart, RouteConfigLoadEnd, RouteConfigLoadStart, RoutesRecognized, Scroll } from '@angular/router';\n\nimport { Destroyable              } from '@bespunky/angular-zen/core';\nimport { RouterOutletComponentBus } from '../outlet/router-outlet-component-bus.service';\n\ndeclare const Zone: any;\n\n/**\n * Hard-codes event names as strings.\n * When AOT compilation is run and constructor names change, the dispatcher will still be able to get a hold\n * of the correct event name using this map.\n */\nconst EventMap = {\n    [NavigationStart     .prototype.constructor.name]: 'NavigationStart',\n    [RouteConfigLoadStart.prototype.constructor.name]: 'RouteConfigLoadStart',\n    [RouteConfigLoadEnd  .prototype.constructor.name]: 'RouteConfigLoadEnd',\n    [RoutesRecognized    .prototype.constructor.name]: 'RoutesRecognized',\n    [GuardsCheckStart    .prototype.constructor.name]: 'GuardsCheckStart',\n    [ChildActivationStart.prototype.constructor.name]: 'ChildActivationStart',\n    [ActivationStart     .prototype.constructor.name]: 'ActivationStart',\n    [GuardsCheckEnd      .prototype.constructor.name]: 'GuardsCheckEnd',\n    [ResolveStart        .prototype.constructor.name]: 'ResolveStart',\n    [ResolveEnd          .prototype.constructor.name]: 'ResolveEnd',\n    [ChildActivationEnd  .prototype.constructor.name]: 'ChildActivationEnd',\n    [ActivationEnd       .prototype.constructor.name]: 'ActivationEnd',\n    [NavigationEnd       .prototype.constructor.name]: 'NavigationEnd',\n    [NavigationCancel    .prototype.constructor.name]: 'NavigationCancel',\n    [NavigationError     .prototype.constructor.name]: 'NavigationError',\n    [Scroll              .prototype.constructor.name]: 'Scroll'\n};\n\n/** Represents a function that creates an async task to be run (normally on a component). */\nexport type Resolver = (component: any, ...resolverArgs: any[]) => Observable<any> | InteropObservable<any> | Promise<any>;\n\n/**\n * The prefix of the id generated for zone macro tasks when calling `RouteAware.resolveInMacroTask()`.\n * \n * Generated ids will confrom to a `{prefix}-{random number}` format.\n */\nexport const ResolverMacroTaskIdPrefix = 'route-aware-resolver';\n\n/**\n * Provides functionality for extending class to easily work with routes and process changes.\n *\n * @export\n * @abstract\n * @class RouteAware\n * @extends {Destroyable}\n */\n@Directive()  // Originally this was decorated with `Directive` only so angular accepts it as base for both services and components.\n@Injectable() // However, compodoc fails to collect abstract classes marked with `Directive` so I marked it as both. Tests pass, POC stackblitz doesn't show side effects.\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class RouteAware extends Destroyable\n{    \n    /**\n     * Creates an instance of RouteAware.\n     * \n     * @param {Router} router The instance of Angular's router service.\n     * @param {ActivatedRoute} route The instance of Angular's active route service.\n     * @param {RouterOutletComponentBus} [componentBus] (Optional) The component bus for router-x functionality.\n     * Provide this when you want your route-aware service to have access to the instance(s) of the activated component(s).\n     */\n    constructor(\n        protected router       : Router,\n        protected route        : ActivatedRoute,\n        protected componentBus?: RouterOutletComponentBus\n    )\n    {\n        super();\n\n        // TODO: Scan class and only subscribe if handlers were defined\n        this.subscribe(this.router.events, this.dispatchRouterEvent.bind(this));\n    }\n    \n    /**\n     * Checks if a handler method for the specific event type exists on the service and calls it.\n     * Handler methods should comply with `onEventType` naming (lowercase 'on', first-upper event type).\n     * \n     * @private\n     * @param {Event} event The event data received from the router.\n     */\n    private dispatchRouterEvent(event: Event): void\n    {\n        // AOT compilation changes class names, causing the dispacher to look for a handler methods with\n        // wrong names (e.g. `onJ`). The EventMap is used to restore the original names.\n        const typeName    = event.constructor.name;\n        const handlerName = `on${EventMap[typeName]}`;\n        const handle      = (this as any)[handlerName];\n\n        if (handle) handle.call(this, event);\n    }\n\n    /**\n     * Creates an observable that emits only the specified router events and is automatically destroyed when the service/component is destroyed.\n     *\n     * @protected\n     * @template TEvent The type of router event to emit.\n     * @param {Type<TEvent>} eventType The type of router event to emit.\n     * @param {boolean} [autoUnsubscribe=true] (Optional) `true` to make the observable complete when the service/component is destroyed; otherwise `false`. Default is `true`.\n     * @returns {Observable<TEvent>}\n     */\n    protected observeRouterEvent<TEvent extends Event>(eventType: Type<TEvent>, autoUnsubscribe: boolean = true): Observable<TEvent>\n    {\n        let observable = this.router.events;\n\n        if (autoUnsubscribe) observable = observable.pipe(takeUntil(this.destroyed));\n        \n        return observable.pipe(filter(event => event.constructor === eventType)) as Observable<TEvent>;\n    }\n\n    /**\n     * Recoursively runs a processing function on the route and its children.\n     * Scan is done from parent to child, meaning the parent is the first to process.\n     *\n     * @ignore\n     * @protected\n     * @param {ActivatedRouteSnapshot} route The top route on which to apply the processing function.\n     * @param {(route: ActivatedRouteSnapshot, component: any) => boolean} process The function to run on the route and its children. The function receives a `route` argument which reflects the route being processed,\n     * and a `component` argument which reflects the component that was loaded for the route's outlet.\n     * If the corresponding outlet wasn't marked with the `publishComponent` directive, the `component` argument will be null.\n     * \n     * Returning `true` from the process function is equal to saying 'work has completed' and will stop propogation to the route's children.\n     * @param {number} [levels=-1] (Optional) The number of levels (excluding the parent) to dive deeper into the route tree.\n     * A value of 1 for example, will process the route and its first-level children only. By default, scans all levels of the route tree.\n     */\n    protected deepScanRoute(route: ActivatedRouteSnapshot, process: (route: ActivatedRouteSnapshot, component: any) => boolean  , levels?: number): void;\n    /**\n     * Recoursively runs a processing function on the route and its children.\n     * Scan is done from parent to child, meaning the parent is the first to process.\n     *\n     * @ignore\n     * @protected\n     * @param {ActivatedRouteSnapshot} route The top route on which to apply the processing function.\n     * @param {(route: ActivatedRouteSnapshot, component: any) => void} process The function to run on the route and its children. The function receives a `route` argument which reflects the route being processed,\n     * and a `component` argument which reflects the component that was loaded for the route's outlet.\n     * If the corresponding outlet wasn't marked with the `publishComponent` directive, the `component` argument will be null.\n     * \n     * Returning `true` from the process function is equal to saying 'work has completed' and will stop propogation to the route's children.\n     * @param {number} [levels=-1] (Optional) The number of levels (excluding the parent) to dive deeper into the route tree.\n     * A value of 1 for example, will process the route and its first-level children only. By default, scans all levels of the route tree.\n     */\n    protected deepScanRoute(route: ActivatedRouteSnapshot, process: (route: ActivatedRouteSnapshot, component: any) => void, levels?: number): void;\n    /**\n     * Recoursively runs a processing function on the route and its children.\n     * Scan is done from parent to child, meaning the parent is the first to process.\n     * \n     * @protected\n     * @param {ActivatedRouteSnapshot} route The top route on which to apply the processing function.\n     * @param {(route: ActivatedRouteSnapshot, component: any) => boolean | void} process The function to run on the route and its children. The function receives a `route` argument which reflects the route being processed,\n     * and a `component` argument which reflects the component that was loaded for the route's outlet.\n     * If the corresponding outlet wasn't marked with the `publishComponent` directive, the `component` argument will be null.\n     * \n     * Returning `true` from the process function is equal to saying 'work has completed' and will stop propogation to the route's children.\n     * @param {number} [levels=-1] (Optional) The number of levels (excluding the parent) to dive deeper into the route tree.\n     * A value of 1 for example, will process the route and its first-level children only. By default, scans all levels of the route tree.\n     */\n    protected deepScanRoute(route: ActivatedRouteSnapshot, process: (route: ActivatedRouteSnapshot, component: any) => boolean | void, levels: number = -1): void\n    {\n        // Make sure the caller wants scan to proceed, then make sure level limit wasn't reached.\n        const processingConcluded = process(route, this.componentBus?.instance(route.outlet));\n        // Negative values will scan all, positives will scan until reaching zero.\n        const shouldScanChildren  = !processingConcluded && levels !== 0;\n\n        if (shouldScanChildren && route.children) route.children.forEach(childRoute => this.deepScanRoute(childRoute, process, levels - 1));\n    }\n    \n    /**\n     * Creates an observable that runs all the specified resolvers and concats their results as an array.\n     * The resolvers will be passed with the instance of the component for the currently activated route.\n     *\n     * @protected\n     * @param {(Resolver | Resolver[])} resolvers The resolver(s) to concat.\n     * @param {...any[]} resolverArgs (Optional) Any arguments to pass into the resolvers in addition to the component.\n     * @returns {Observable<any[]>} An array with the concatenated results of the resolvers.\n     */\n    protected resolve(resolvers: Resolver | Resolver[], ...resolverArgs: any[]): Observable<any[]>\n    {\n        if (!resolvers) return of([]);\n\n        // Cast array\n        if (!Array.isArray(resolvers)) resolvers = [resolvers];\n\n        // Run resolvers to create observable tasks\n        const observables = resolvers.map(resolve => resolve(this.activatedRouteComponent, ...resolverArgs));\n        \n        // Run tasks and output their returned data as an array\n        return from(observables).pipe(concatAll(), toArray());\n    }\n\n    /**\n     * Creates an observable that runs all the specified resolvers and concats their results as an array.\n     * The resolvers will be passed with the instance of the component for the currently activated route.\n     * \n     * **Angular Universal:**\n     * In SSR, the server doesn't wait for async code to complete. The result is scrapers and search engines receiving a page without resolved data,\n     * which is bad in case you need them to read some resolved metadata tags for example.\n     * \n     * Using `Zone` directly, this method creates a macro task and completes it when resolves are done or have errored.\n     * This makes the server block and wait until everything is resolved or errors before returning the rendered page.\n     * \n     * > *ℹ Make sure your resolves and process function are fast enough so that the server won't hang too much trying to render.*\n     *\n     * @see https://stackoverflow.com/a/50065783/4371525 for the discussion.\n     *\n     * @see {ResolverMacroTaskIdPrefix} if you need to identify the created macro task in your code.\n     * \n     * @protected\n     * @param {(Resolver | Resolver[])} resolvers The resolver(s) to concat.\n     * @param {...any[]} resolverArgs (Optional) Any arguments to pass into the resolvers in addition to the component.\n     */\n    protected resolveInMacroTask(resolvers: Resolver | Resolver[], ...resolverArgs: any[]): Observable<any[]>\n    {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        const macroTask = Zone.current.scheduleMacroTask(`${ResolverMacroTaskIdPrefix}-${Math.random()}`, () => { }, {}, () => { }, () => { });\n\n        return this.resolve(resolvers, ...resolverArgs)\n            // Signal end of macro task on completion or error and allow server to return\n            .pipe(finalize(() => macroTask.invoke())\n        );\n    }\n\n    /**\n     * The instance of the component created for the currently activated route.\n     * If no component bus was supplied at construction time, this will be `undefined`.\n     *\n     * @readonly\n     * @protected\n     * @type {(any | null)}\n     */\n    protected get activatedRouteComponent(): any | null\n    {\n        return this.componentBus?.instance(this.route.outlet);\n    }\n}\n"]}