@stemy/ngx-utils 13.6.17 → 17.0.0

package/{esm2020 → esm2022}/ngx-utils/services/promise.service.mjs

@@ -1,55 +1,55 @@
-import { EventEmitter, Inject, Injectable, NgZone } from "@angular/core";
-import * as i0 from "@angular/core";
-export class PromiseService {
-    constructor(zone) {
-        this.zone = zone;
-        this.promiseCount = 0;
-        this.promiseChanged = new EventEmitter();
-    }
-    get count() {
-        return this.promiseCount;
-    }
-    get onChanged() {
-        return this.promiseChanged;
-    }
-    create(executor) {
-        return this.add(this.zone.runOutsideAngular(() => new Promise(executor)));
-    }
-    all(promises) {
-        return this.add(this.zone.runOutsideAngular(() => Promise.all(promises)));
-    }
-    resolve(value) {
-        return this.add(this.zone.runOutsideAngular(() => Promise.resolve(value)));
-    }
-    reject(value) {
-        return this.add(this.zone.runOutsideAngular(() => Promise.reject(value)));
-    }
-    promiseFinished() {
-        if (this.promiseCount == 0)
-            return;
-        this.promiseCount--;
-        this.promiseChanged.emit(this.promiseCount);
-    }
-    add(promise) {
-        this.promiseCount++;
-        this.promiseChanged.emit(this.promiseCount);
-        return new Promise((resolve, reject) => {
-            promise.then(v => {
-                resolve(v);
-                this.promiseFinished();
-            }, r => {
-                reject(r);
-                this.promiseFinished();
-            });
-        });
-    }
-}
-PromiseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: PromiseService, deps: [{ token: NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-PromiseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: PromiseService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: PromiseService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.NgZone, decorators: [{
-                    type: Inject,
-                    args: [NgZone]
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvbWlzZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy9zZXJ2aWNlcy9wcm9taXNlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFJdkUsTUFBTSxPQUFPLGNBQWM7SUFhdkIsWUFBcUMsSUFBWTtRQUFaLFNBQUksR0FBSixJQUFJLENBQVE7UUFDN0MsSUFBSSxDQUFDLFlBQVksR0FBRyxDQUFDLENBQUM7UUFDdEIsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLFlBQVksRUFBVSxDQUFDO0lBQ3JELENBQUM7SUFkRCxJQUFJLEtBQUs7UUFDTCxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDN0IsQ0FBQztJQUVELElBQUksU0FBUztRQUNULE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQztJQUMvQixDQUFDO0lBVUQsTUFBTSxDQUFJLFFBQWlHO1FBQ3ZHLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksT0FBTyxDQUFJLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNqRixDQUFDO0lBRUQsR0FBRyxDQUFDLFFBQXdCO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFRCxPQUFPLENBQUksS0FBeUI7UUFDaEMsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUVELE1BQU0sQ0FBSSxLQUF5QjtRQUMvQixPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBRVMsZUFBZTtRQUNyQixJQUFJLElBQUksQ0FBQyxZQUFZLElBQUksQ0FBQztZQUFFLE9BQU87UUFDbkMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3BCLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBRVMsR0FBRyxDQUFJLE9BQW1CO1FBQ2hDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUNwQixJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDNUMsT0FBTyxJQUFJLE9BQU8sQ0FBTSxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtZQUN4QyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFO2dCQUNiLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDWCxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDM0IsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFO2dCQUNILE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFDVixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7WUFDM0IsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7OzJHQXBEUSxjQUFjLGtCQWFILE1BQU07K0dBYmpCLGNBQWM7MkZBQWQsY0FBYztrQkFEMUIsVUFBVTs7MEJBY00sTUFBTTsyQkFBQyxNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFdmVudEVtaXR0ZXIsIEluamVjdCwgSW5qZWN0YWJsZSwgTmdab25lfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0lQcm9taXNlU2VydmljZX0gZnJvbSBcIi4uL2NvbW1vbi10eXBlc1wiO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgUHJvbWlzZVNlcnZpY2UgaW1wbGVtZW50cyBJUHJvbWlzZVNlcnZpY2Uge1xyXG5cclxuICAgIGdldCBjb3VudCgpOiBudW1iZXIge1xyXG4gICAgICAgIHJldHVybiB0aGlzLnByb21pc2VDb3VudDtcclxuICAgIH1cclxuXHJcbiAgICBnZXQgb25DaGFuZ2VkKCk6IEV2ZW50RW1pdHRlcjxudW1iZXI+IHtcclxuICAgICAgICByZXR1cm4gdGhpcy5wcm9taXNlQ2hhbmdlZDtcclxuICAgIH1cclxuXHJcbiAgICBwcm90ZWN0ZWQgcHJvbWlzZUNvdW50OiBudW1iZXI7XHJcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgcHJvbWlzZUNoYW5nZWQ6IEV2ZW50RW1pdHRlcjxudW1iZXI+O1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKEBJbmplY3QoTmdab25lKSByZWFkb25seSB6b25lOiBOZ1pvbmUpIHtcclxuICAgICAgICB0aGlzLnByb21pc2VDb3VudCA9IDA7XHJcbiAgICAgICAgdGhpcy5wcm9taXNlQ2hhbmdlZCA9IG5ldyBFdmVudEVtaXR0ZXI8bnVtYmVyPigpO1xyXG4gICAgfVxyXG5cclxuICAgIGNyZWF0ZTxUPihleGVjdXRvcjogKHJlc29sdmU6ICh2YWx1ZT86IFQgfCBQcm9taXNlTGlrZTxUPikgPT4gdm9pZCwgcmVqZWN0OiAocmVhc29uPzogYW55KSA9PiB2b2lkKSA9PiB2b2lkKTogUHJvbWlzZTxUPiB7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuYWRkKHRoaXMuem9uZS5ydW5PdXRzaWRlQW5ndWxhcigoKSA9PiBuZXcgUHJvbWlzZTxUPihleGVjdXRvcikpKTtcclxuICAgIH1cclxuXHJcbiAgICBhbGwocHJvbWlzZXM6IFByb21pc2U8YW55PltdKTogUHJvbWlzZTxhbnk+IHtcclxuICAgICAgICByZXR1cm4gdGhpcy5hZGQodGhpcy56b25lLnJ1bk91dHNpZGVBbmd1bGFyKCgpID0+IFByb21pc2UuYWxsKHByb21pc2VzKSkpO1xyXG4gICAgfVxyXG5cclxuICAgIHJlc29sdmU8VD4odmFsdWU6IFQgfCBQcm9taXNlTGlrZTxUPik6IFByb21pc2U8VD4ge1xyXG4gICAgICAgIHJldHVybiB0aGlzLmFkZCh0aGlzLnpvbmUucnVuT3V0c2lkZUFuZ3VsYXIoKCkgPT4gUHJvbWlzZS5yZXNvbHZlKHZhbHVlKSkpO1xyXG4gICAgfVxyXG5cclxuICAgIHJlamVjdDxUPih2YWx1ZTogVCB8IFByb21pc2VMaWtlPFQ+KTogUHJvbWlzZTxUPiB7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuYWRkKHRoaXMuem9uZS5ydW5PdXRzaWRlQW5ndWxhcigoKSA9PiBQcm9taXNlLnJlamVjdCh2YWx1ZSkpKTtcclxuICAgIH1cclxuXHJcbiAgICBwcm90ZWN0ZWQgcHJvbWlzZUZpbmlzaGVkKCk6IHZvaWQge1xyXG4gICAgICAgIGlmICh0aGlzLnByb21pc2VDb3VudCA9PSAwKSByZXR1cm47XHJcbiAgICAgICAgdGhpcy5wcm9taXNlQ291bnQtLTtcclxuICAgICAgICB0aGlzLnByb21pc2VDaGFuZ2VkLmVtaXQodGhpcy5wcm9taXNlQ291bnQpO1xyXG4gICAgfVxyXG5cclxuICAgIHByb3RlY3RlZCBhZGQ8VD4ocHJvbWlzZTogUHJvbWlzZTxUPik6IFByb21pc2U8VD4ge1xyXG4gICAgICAgIHRoaXMucHJvbWlzZUNvdW50Kys7XHJcbiAgICAgICAgdGhpcy5wcm9taXNlQ2hhbmdlZC5lbWl0KHRoaXMucHJvbWlzZUNvdW50KTtcclxuICAgICAgICByZXR1cm4gbmV3IFByb21pc2U8YW55PigocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XHJcbiAgICAgICAgICAgIHByb21pc2UudGhlbih2ID0+IHtcclxuICAgICAgICAgICAgICAgIHJlc29sdmUodik7XHJcbiAgICAgICAgICAgICAgICB0aGlzLnByb21pc2VGaW5pc2hlZCgpO1xyXG4gICAgICAgICAgICB9LCByID0+IHtcclxuICAgICAgICAgICAgICAgIHJlamVjdChyKTtcclxuICAgICAgICAgICAgICAgIHRoaXMucHJvbWlzZUZpbmlzaGVkKCk7XHJcbiAgICAgICAgICAgIH0pO1xyXG4gICAgICAgIH0pO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==
+import { EventEmitter, Inject, Injectable, NgZone } from "@angular/core";
+import * as i0 from "@angular/core";
+export class PromiseService {
+    get count() {
+        return this.promiseCount;
+    }
+    get onChanged() {
+        return this.promiseChanged;
+    }
+    constructor(zone) {
+        this.zone = zone;
+        this.promiseCount = 0;
+        this.promiseChanged = new EventEmitter();
+    }
+    create(executor) {
+        return this.add(this.zone.runOutsideAngular(() => new Promise(executor)));
+    }
+    all(promises) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.all(promises)));
+    }
+    resolve(value) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.resolve(value)));
+    }
+    reject(value) {
+        return this.add(this.zone.runOutsideAngular(() => Promise.reject(value)));
+    }
+    promiseFinished() {
+        if (this.promiseCount == 0)
+            return;
+        this.promiseCount--;
+        this.promiseChanged.emit(this.promiseCount);
+    }
+    add(promise) {
+        this.promiseCount++;
+        this.promiseChanged.emit(this.promiseCount);
+        return new Promise((resolve, reject) => {
+            promise.then(v => {
+                resolve(v);
+                this.promiseFinished();
+            }, r => {
+                reject(r);
+                this.promiseFinished();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PromiseService, deps: [{ token: NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PromiseService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PromiseService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngx-utils/services/state.service.mjs

@@ -0,0 +1,177 @@
+import { Injectable, Injector, NgZone, Optional } from "@angular/core";
+import { ActivatedRouteSnapshot, ChildrenOutletContexts, NavigationEnd, Router } from "@angular/router";
+import { BehaviorSubject, Observable } from "rxjs";
+import { skipWhile, distinctUntilChanged, delay } from "rxjs/operators";
+import { ObjectUtils } from "../utils/object.utils";
+import { UniversalService } from "./universal.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./universal.service";
+import * as i2 from "@angular/router";
+export const emptySnapshot = new ActivatedRouteSnapshot();
+export const emptyData = { id: "" };
+export const emptyParams = {};
+export const emptySegments = [];
+export const emptyComponents = [];
+export class StateService extends BehaviorSubject {
+    static toPath(route, params) {
+        let path = route.path || "";
+        ObjectUtils.iterate(params, (value, key) => {
+            path = path.replace(`:${key}`, `${value}`);
+        });
+        return path;
+    }
+    get component() {
+        return this.comp;
+    }
+    get snapshot() {
+        return this.shot || emptySnapshot;
+    }
+    get route() {
+        return this.snapshot.routeConfig;
+    }
+    get data() {
+        return this.snapshot.data || emptyData;
+    }
+    get params() {
+        return this.snapshot.params || emptyParams;
+    }
+    get queryParams() {
+        return this.snapshot.queryParams || emptyParams;
+    }
+    get url() {
+        return this.stateInfo.url || "";
+    }
+    get urlSegments() {
+        return this.stateInfo.segments || emptySegments;
+    }
+    get components() {
+        return this.stateInfo.components || emptyComponents;
+    }
+    get routerConfig() {
+        return this.router.config;
+    }
+    constructor(injector, zone, universal, router = null, contexts = null) {
+        super(null);
+        this.injector = injector;
+        this.zone = zone;
+        this.universal = universal;
+        this.router = router;
+        this.contexts = contexts;
+        this.handleRouterEvent = (event) => {
+            if (!(event instanceof NavigationEnd))
+                return;
+            const routerStateSnapshot = this.router.routerState.snapshot;
+            let snapshot = routerStateSnapshot.root;
+            let context = this.contexts?.getContext("primary");
+            let segments = snapshot.url;
+            const components = [];
+            const snapshots = [];
+            while (snapshot) {
+                snapshots.push(snapshot);
+                segments = segments.concat(snapshot.url);
+                if (context) {
+                    if (context.outlet && context.outlet.component)
+                        components.push(context.outlet.component);
+                    context = context.children.getContext("primary");
+                }
+                snapshot = snapshot.firstChild;
+            }
+            this.comp = components[components.length - 1];
+            this.shot = snapshots[snapshots.length - 1];
+            this.stateInfo = {
+                url: routerStateSnapshot.url,
+                segments: segments,
+                components: components
+            };
+            this.next(this.shot);
+        };
+        if (!this.router)
+            return;
+        this.globalExtras = {
+            queryParamsHandling: "merge"
+        };
+        this.router.events
+            .pipe(distinctUntilChanged(), delay(10))
+            .subscribe(this.handleRouterEvent);
+        this.stateInfo = {
+            url: "",
+            segments: [],
+            components: []
+        };
+    }
+    async reload() {
+        const routerStateSnapshot = this.router.routerState.snapshot;
+        const resolvers = this.route.resolve || {};
+        const keys = Object.keys(resolvers);
+        for (const key of keys) {
+            const resolver = this.injector.get(resolvers[key]);
+            let resolved = resolver.resolve(this.snapshot, routerStateSnapshot);
+            if (resolved instanceof Observable) {
+                resolved = resolved.toPromise();
+            }
+            if (resolved instanceof Promise) {
+                resolved = await resolved;
+            }
+            this.data[key] = resolved;
+        }
+    }
+    async navigateByUrl(url, navigationExtras = {}) {
+        return this.navigate(url, navigationExtras);
+    }
+    async navigate(url, navigationExtras = {}) {
+        if (!this.router)
+            return false;
+        const [tree, extras] = this.createUrlTree(url, navigationExtras);
+        return this.zone.run(() => {
+            return this.router.navigateByUrl(tree, extras);
+        });
+    }
+    async open(url, target = "_blank", navigationExtras = {}) {
+        if (!this.router)
+            return false;
+        const [tree, extras] = this.createUrlTree(url, navigationExtras);
+        return this.zone.run(() => {
+            return this.openInNewWindow(tree, target) || this.router.navigateByUrl(tree, extras);
+        });
+    }
+    subscribeImmediately(next, error, complete) {
+        return this.pipe(skipWhile(v => v == null)).subscribe(next, error, complete);
+    }
+    openInNewWindow(tree, target) {
+        if (!this.universal.isBrowser)
+            return false;
+        const baseUrl = window.location.href.replace(this.router.url, "");
+        try {
+            const serialized = this.router.serializeUrl(tree);
+            const separator = serialized.startsWith("/") ? "" : "/";
+            window.open(baseUrl + separator + serialized, target);
+            return true;
+        }
+        catch (e) {
+            console.log(`Can't open new window: ${e}`);
+            return false;
+        }
+    }
+    createUrlTree(url, extras) {
+        if (!this.router)
+            return null;
+        extras = Object.assign(extras, this.globalExtras, extras || {});
+        if (ObjectUtils.isArray(url)) {
+            return [this.router.createUrlTree(url, extras), extras];
+        }
+        if (ObjectUtils.isString(url)) {
+            return [this.router.parseUrl(url), extras];
+        }
+        return [url, extras];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StateService, deps: [{ token: i0.Injector }, { token: i0.NgZone }, { token: i1.UniversalService }, { token: i2.Router, optional: true }, { token: i2.ChildrenOutletContexts, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.NgZone }, { type: i1.UniversalService }, { type: i2.Router, decorators: [{
+                    type: Optional
+                }] }, { type: i2.ChildrenOutletContexts, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, Injector, NgZone, Optional} from \"@angular/core\";\r\nimport {\r\n    ActivatedRouteSnapshot,\r\n    ChildrenOutletContexts,\r\n    Data,\r\n    Event,\r\n    NavigationEnd,\r\n    NavigationExtras,\r\n    OutletContext,\r\n    Params,\r\n    Resolve,\r\n    Route,\r\n    Router,\r\n    UrlSegment,\r\n    UrlTree\r\n} from \"@angular/router\";\r\nimport {BehaviorSubject, Observable, Subscription} from \"rxjs\";\r\nimport {skipWhile, distinctUntilChanged, delay} from \"rxjs/operators\";\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\nimport {IRoute, NavigationUrlParam} from \"../common-types\";\r\nimport {UniversalService} from \"./universal.service\";\r\n\r\nexport const emptySnapshot: ActivatedRouteSnapshot = new ActivatedRouteSnapshot();\r\nexport const emptyData: Data = {id: \"\"};\r\nexport const emptyParams: Params = {};\r\nexport const emptySegments: UrlSegment[] = [];\r\nexport const emptyComponents: any[] = [];\r\n\r\nexport interface IStateInfo {\r\n    url: string;\r\n    segments: UrlSegment[];\r\n    components: any[];\r\n}\r\n\r\n@Injectable()\r\nexport class StateService extends BehaviorSubject<any> {\r\n\r\n    readonly globalExtras: NavigationExtras;\r\n\r\n    private shot: ActivatedRouteSnapshot;\r\n    private comp: any;\r\n    private stateInfo: IStateInfo;\r\n\r\n    static toPath(route: Route, params: any): string {\r\n        let path = route.path || \"\";\r\n        ObjectUtils.iterate(params, (value: any, key: string) => {\r\n            path = path.replace(`:${key}`, `${value}`);\r\n        });\r\n        return path;\r\n    }\r\n\r\n    get component(): any {\r\n        return this.comp;\r\n    }\r\n\r\n    get snapshot(): ActivatedRouteSnapshot {\r\n        return this.shot || emptySnapshot;\r\n    }\r\n\r\n    get route(): IRoute {\r\n        return this.snapshot.routeConfig;\r\n    }\r\n\r\n    get data(): Data {\r\n        return this.snapshot.data || emptyData;\r\n    }\r\n\r\n    get params(): Params {\r\n        return this.snapshot.params || emptyParams;\r\n    }\r\n\r\n    get queryParams(): Params {\r\n        return this.snapshot.queryParams || emptyParams;\r\n    }\r\n\r\n    get url(): string {\r\n        return this.stateInfo.url || \"\";\r\n    }\r\n\r\n    get urlSegments(): UrlSegment[] {\r\n        return this.stateInfo.segments || emptySegments;\r\n    }\r\n\r\n    get components(): any[] {\r\n        return this.stateInfo.components || emptyComponents;\r\n    }\r\n\r\n    get routerConfig(): IRoute[] {\r\n        return this.router.config;\r\n    }\r\n\r\n    constructor(readonly injector: Injector,\r\n                readonly zone: NgZone,\r\n                readonly universal: UniversalService,\r\n                @Optional() readonly router: Router = null,\r\n                @Optional() readonly contexts: ChildrenOutletContexts = null) {\r\n        super(null);\r\n        if (!this.router) return;\r\n        this.globalExtras = {\r\n            queryParamsHandling: \"merge\"\r\n        };\r\n        this.router.events\r\n            .pipe(\r\n                distinctUntilChanged(),\r\n                delay(10)\r\n            )\r\n            .subscribe(this.handleRouterEvent);\r\n        this.stateInfo = {\r\n            url: \"\",\r\n            segments: [],\r\n            components: []\r\n        };\r\n    }\r\n\r\n    async reload(): Promise<any> {\r\n        const routerStateSnapshot = this.router.routerState.snapshot;\r\n        const resolvers = this.route.resolve || {};\r\n        const keys = Object.keys(resolvers);\r\n        for (const key of keys) {\r\n            const resolver = this.injector.get(resolvers[key]) as Resolve<any>;\r\n            let resolved = resolver.resolve(this.snapshot, routerStateSnapshot);\r\n            if (resolved instanceof Observable) {\r\n                resolved = resolved.toPromise();\r\n            }\r\n            if (resolved instanceof Promise) {\r\n                resolved = await resolved;\r\n            }\r\n            this.data[key] = resolved;\r\n        }\r\n    }\r\n\r\n    async navigateByUrl(url: string | UrlTree, navigationExtras: NavigationExtras = {}): Promise<boolean> {\r\n        return this.navigate(url, navigationExtras);\r\n    }\r\n\r\n    async navigate(url: NavigationUrlParam, navigationExtras: NavigationExtras = {}): Promise<boolean> {\r\n        if (!this.router) return false;\r\n        const [tree, extras] = this.createUrlTree(url, navigationExtras);\r\n        return this.zone.run(() => {\r\n            return this.router.navigateByUrl(tree, extras);\r\n        });\r\n    }\r\n\r\n    async open(url: NavigationUrlParam, target = \"_blank\", navigationExtras: NavigationExtras = {}): Promise<boolean> {\r\n        if (!this.router) return false;\r\n        const [tree, extras] = this.createUrlTree(url, navigationExtras);\r\n        return this.zone.run(() => {\r\n            return this.openInNewWindow(tree, target) || this.router.navigateByUrl(tree, extras);\r\n        });\r\n    }\r\n\r\n    subscribeImmediately(next?: (value: ActivatedRouteSnapshot) => void, error?: (error: any) => void, complete?: () => void): Subscription {\r\n        return this.pipe(skipWhile(v => v == null)).subscribe(next, error, complete);\r\n    }\r\n\r\n    protected openInNewWindow(tree: UrlTree, target: string): boolean {\r\n        if (!this.universal.isBrowser) return false;\r\n        const baseUrl = window.location.href.replace(this.router.url, \"\");\r\n        try {\r\n            const serialized = this.router.serializeUrl(tree);\r\n            const separator = serialized.startsWith(\"/\") ? \"\" : \"/\";\r\n            window.open(baseUrl + separator + serialized, target);\r\n            return true;\r\n        } catch (e) {\r\n            console.log(`Can't open new window: ${e}`);\r\n            return false;\r\n        }\r\n    }\r\n\r\n    protected createUrlTree(url: NavigationUrlParam, extras?: NavigationExtras): [UrlTree, NavigationExtras] {\r\n        if (!this.router) return null;\r\n        extras = Object.assign(extras, this.globalExtras, extras || {});\r\n        if (ObjectUtils.isArray(url)) {\r\n            return [this.router.createUrlTree(url, extras), extras]\r\n        }\r\n        if (ObjectUtils.isString(url)) {\r\n            return [this.router.parseUrl(url), extras];\r\n        }\r\n        return [url, extras];\r\n    }\r\n\r\n    protected handleRouterEvent = (event: Event): void => {\r\n        if (!(event instanceof NavigationEnd)) return;\r\n        const routerStateSnapshot = this.router.routerState.snapshot;\r\n        let snapshot = routerStateSnapshot.root;\r\n        let context: OutletContext = this.contexts?.getContext(\"primary\");\r\n        let segments = snapshot.url;\r\n        const components: any[] = [];\r\n        const snapshots: ActivatedRouteSnapshot[] = [];\r\n        while (snapshot) {\r\n            snapshots.push(snapshot);\r\n            segments = segments.concat(snapshot.url);\r\n            if (context) {\r\n                if (context.outlet && context.outlet.component)\r\n                    components.push(context.outlet.component);\r\n                context = context.children.getContext(\"primary\");\r\n            }\r\n            snapshot = snapshot.firstChild;\r\n        }\r\n        this.comp = components[components.length - 1];\r\n        this.shot = snapshots[snapshots.length - 1];\r\n        this.stateInfo = {\r\n            url: routerStateSnapshot.url,\r\n            segments: segments,\r\n            components: components\r\n        };\r\n        this.next(this.shot);\r\n    };\r\n}\r\n"]}