@worktile/planet 12.1.0 → 12.1.1

package/packages/planet/src/application/planet-application-ref.spec.ts

@@ -0,0 +1,233 @@
+import { PlanetPortalApplication } from './portal-application';
+import { NgModule, Compiler, Injector, Component, NgZone, Type } from '@angular/core';
+import { Router } from '@angular/router';
+import { TestBed, inject, tick, fakeAsync, flush } from '@angular/core/testing';
+import { defineApplication, getPlanetApplicationRef, clearGlobalPlanet } from '../global-planet';
+import { Subject } from 'rxjs';
+import { PlanetApplicationRef } from './planet-application-ref';
+import { RouterTestingModule } from '@angular/router/testing';
+
+@Component({
+    selector: 'app-root',
+    template: `
+        <router-outlet></router-outlet>
+    `
+})
+class EmptyComponent {}
+@NgModule({
+    declarations: [EmptyComponent],
+    imports: [
+        RouterTestingModule.withRoutes([
+            {
+                path: 'app1',
+                component: EmptyComponent
+            },
+            {
+                path: 'app1/test',
+                component: EmptyComponent
+            }
+        ])
+    ]
+})
+class AppModule {}
+
+describe('PlanetApplicationRef', () => {
+    afterEach(() => {
+        clearGlobalPlanet();
+    });
+
+    describe('getPlanetApplicationRef', () => {
+        it('should get planet application ref success', () => {
+            defineApplication('app1', {
+                template: '<app1-root></app1-root>',
+                bootstrap: (portalApp?: PlanetPortalApplication) => {
+                    return new Promise(() => {});
+                }
+            });
+            const planetAppRef = getPlanetApplicationRef('app1');
+            expect(planetAppRef).toBeTruthy();
+            expect(planetAppRef).toBe(window['planet'].apps['app1']);
+        });
+
+        it('should not get planet appRef which has not exist', () => {
+            defineApplication('app1', {
+                template: '<app1-root></app1-root>',
+                bootstrap: (portalApp?: PlanetPortalApplication) => {
+                    return new Promise(() => {});
+                }
+            });
+            const planetAppRef = getPlanetApplicationRef('app2');
+            expect(planetAppRef).toBeFalsy();
+        });
+    });
+
+    describe('ApplicationRef', () => {
+        let compiler: Compiler;
+        let injector: Injector;
+
+        function bootstrapApp1<T>(moduleType?: Type<T>) {
+            const portalApplication = new PlanetPortalApplication();
+            const ngModuleFactory = compiler.compileModuleSync(moduleType ? moduleType : AppModule);
+            const ngModuleRef = ngModuleFactory.create(injector);
+            const router = ngModuleRef.injector.get(Router);
+            defineApplication('app1', {
+                template: '<app1-root></app1-root>',
+                bootstrap: (portalApp?: PlanetPortalApplication) => {
+                    return new Promise(resolve => {
+                        expect(portalApp).toBe(portalApplication);
+                        resolve(ngModuleRef);
+                    });
+                }
+            });
+
+            const appRef = getPlanetApplicationRef('app1');
+            appRef.bootstrap(portalApplication).subscribe();
+
+            flush();
+            return {
+                router,
+                appRef
+            };
+        }
+
+        beforeEach(() => {
+            TestBed.configureTestingModule({});
+        });
+
+        beforeEach(inject([Compiler, Injector], (_compiler: Compiler, _injector: Injector) => {
+            compiler = _compiler;
+            injector = _injector;
+        }));
+
+        it(`should bootstrap application ref`, fakeAsync(() => {
+            const portalApplication = new PlanetPortalApplication();
+            const ngModuleFactory = compiler.compileModuleSync(AppModule);
+            const ngModuleRef = ngModuleFactory.create(injector);
+            defineApplication('app1', {
+                template: '<app1-root></app1-root>',
+                bootstrap: (portalApp?: PlanetPortalApplication) => {
+                    return new Promise(resolve => {
+                        expect(portalApp).toBe(portalApplication);
+                        resolve(ngModuleRef);
+                    });
+                }
+            });
+            const appRef = getPlanetApplicationRef('app1');
+            expect(appRef).toBeTruthy();
+            const bootstrapSpy = jasmine.createSpy('bootstrap spy');
+            appRef.bootstrap(portalApplication).subscribe(bootstrapSpy);
+            expect(appRef.bootstrapped).toEqual(false);
+            flush();
+            expect(appRef.bootstrapped).toEqual(true);
+            expect(appRef.appModuleRef).toEqual(ngModuleRef);
+            expect(appRef.appModuleRef.instance.appName).toEqual('app1');
+            expect(bootstrapSpy.calls.count()).toEqual(1);
+            expect(bootstrapSpy).toHaveBeenCalled();
+            expect(bootstrapSpy).toHaveBeenCalledWith(appRef);
+        }));
+
+        it(`should destroy application ref success`, fakeAsync(() => {
+            const portalApplication = new PlanetPortalApplication();
+            const ngModuleFactory = compiler.compileModuleSync(AppModule);
+            const ngModuleRef = ngModuleFactory.create(injector);
+            const router = ngModuleRef.injector.get(Router);
+            defineApplication('app1', {
+                template: '<app1-root></app1-root>',
+                bootstrap: (portalApp?: PlanetPortalApplication) => {
+                    return new Promise(resolve => {
+                        expect(portalApp).toBe(portalApplication);
+                        resolve(ngModuleRef);
+                    });
+                }
+            });
+
+            const appRef = getPlanetApplicationRef('app1');
+            appRef.bootstrap(portalApplication).subscribe();
+
+            flush();
+            expect(appRef.bootstrapped).toEqual(true);
+            expect(appRef.appModuleRef).toEqual(ngModuleRef);
+
+            appRef.destroy();
+            expect(appRef.bootstrapped).toEqual(false);
+            expect(appRef.appModuleRef).toEqual(undefined);
+        }));
+
+        it(`should get router success`, fakeAsync(() => {
+            const { appRef, router } = bootstrapApp1();
+            expect(appRef.getRouter()).toBeTruthy();
+            expect(appRef.getRouter()).toEqual(router);
+        }));
+
+        it(`should navigate to url success and get correct current router state url `, fakeAsync(() => {
+            const routerSpy = {
+                navigateByUrl: jasmine.createSpy('navigateByUrl syp'),
+                events: new Subject(),
+                routerState: {
+                    snapshot: {
+                        url: 'app1/hello'
+                    }
+                }
+            };
+            @NgModule({
+                declarations: [],
+                imports: [],
+                providers: [
+                    {
+                        provide: Router,
+                        useValue: routerSpy
+                    }
+                ]
+            })
+            class AppModuleWithSpyRouter {}
+            const { appRef } = bootstrapApp1(AppModuleWithSpyRouter);
+            expect(appRef.getCurrentRouterStateUrl()).toEqual('app1/hello');
+
+            expect(routerSpy.navigateByUrl).not.toHaveBeenCalled();
+
+            const toUrl = 'app2/to-url';
+            appRef.navigateByUrl('app2/to-url');
+
+            expect(routerSpy.navigateByUrl).toHaveBeenCalled();
+            expect(routerSpy.navigateByUrl).toHaveBeenCalledWith(toUrl);
+        }));
+
+        it(`should throw error when app is not defined`, () => {
+            expect(() => {
+                const appRef = new PlanetApplicationRef('app3', {} as any);
+                appRef.bootstrap(undefined);
+            }).toThrowError(`app(app3) is not defined`);
+        });
+
+        it(`should sync portal route change when sub app(app1) route navigate`, fakeAsync(() => {
+            const portalApplication = new PlanetPortalApplication();
+            portalApplication.router = { navigateByUrl: () => {} } as any;
+            const navigateByUrlSpy = spyOn(portalApplication.router, 'navigateByUrl');
+            const ngModuleFactory = compiler.compileModuleSync(AppModule);
+            const ngModuleRef = ngModuleFactory.create(injector);
+            defineApplication('app1', {
+                template: '<app1-root></app1-root>',
+                bootstrap: (portalApp?: PlanetPortalApplication) => {
+                    return new Promise(resolve => {
+                        expect(portalApp).toBe(portalApplication);
+                        resolve(ngModuleRef);
+                    });
+                }
+            });
+            const appRef = getPlanetApplicationRef('app1');
+            expect(appRef).toBeTruthy();
+            appRef.bootstrap(portalApplication);
+
+            const router = ngModuleRef.injector.get(Router);
+            const ngZone = ngModuleRef.injector.get(NgZone);
+            ngZone.run(() => {
+                router.navigateByUrl('/app1');
+            });
+            expect(navigateByUrlSpy).not.toHaveBeenCalled();
+            ngZone.onStable.next();
+            tick();
+            expect(navigateByUrlSpy).toHaveBeenCalled();
+            expect(navigateByUrlSpy).toHaveBeenCalledWith('/app1');
+        }));
+    });
+});

package/packages/planet/src/application/planet-application-ref.ts

@@ -0,0 +1,131 @@
+import { NgModuleRef, NgZone } from '@angular/core';
+import { Router, NavigationEnd } from '@angular/router';
+import { take } from 'rxjs/operators';
+import { Observable, from } from 'rxjs';
+import { PlanetPortalApplication } from './portal-application';
+import { PlantComponentConfig } from '../component/plant-component.config';
+import { PlanetComponentRef } from '../component/planet-component-ref';
+import { getTagNameByTemplate } from '../helpers';
+import { getSandboxInstance, Sandbox } from '../sandbox/';
+
+export interface BootstrapOptions {
+    template: string;
+    bootstrap: BootstrapAppModule;
+}
+
+export type BootstrapAppModule = (portalApp: PlanetPortalApplication) => Promise<NgModuleRef<any> | undefined | null>;
+
+export type PlantComponentFactory = <TData, TComp>(
+    componentName: string,
+    config: PlantComponentConfig<TData>
+) => PlanetComponentRef<TComp>;
+
+export class PlanetApplicationRef {
+    public appModuleRef?: NgModuleRef<any>;
+    public template?: string;
+    private innerSelector?: string;
+    private name: string;
+    private portalApp!: PlanetPortalApplication;
+    private appModuleBootstrap?: BootstrapAppModule;
+    private componentFactory?: PlantComponentFactory;
+
+    public get selector() {
+        return this.innerSelector;
+    }
+
+    public get bootstrapped() {
+        return !!this.appModuleRef;
+    }
+
+    public get ngZone(): NgZone | undefined {
+        return this.appModuleRef?.injector.get(NgZone);
+    }
+
+    public get sandbox(): Sandbox {
+        return getSandboxInstance();
+    }
+
+    constructor(name: string, options?: BootstrapOptions) {
+        this.name = name;
+        if (options) {
+            this.template = options.template;
+            this.innerSelector = this.template ? getTagNameByTemplate(this.template) : '';
+            this.appModuleBootstrap = options.bootstrap;
+        }
+        // This is a hack, since NgZone doesn't allow you to configure the property that identifies your zone.
+        // See https://github.com/PlaceMe-SAS/single-spa-angular-cli/issues/33,
+        NgZone.isInAngularZone = () => {
+            // @ts-ignore
+            return window.Zone.current._properties[`ngx-planet-${name}`] === true;
+        };
+    }
+
+    // 子应用路由变化后同步修改 portal 的 Route
+    private syncPortalRouteWhenNavigationEnd() {
+        const router = this.appModuleRef?.injector.get(Router);
+        if (router) {
+            router.events.subscribe(event => {
+                if (event instanceof NavigationEnd) {
+                    this.ngZone?.onStable
+                        .asObservable()
+                        .pipe(take(1))
+                        .subscribe(() => {
+                            this.portalApp.router!.navigateByUrl(event.url);
+                        });
+                }
+            });
+        }
+    }
+
+    bootstrap(app: PlanetPortalApplication): Observable<this> {
+        if (!this.appModuleBootstrap) {
+            throw new Error(`app(${this.name}) is not defined`);
+        }
+        this.portalApp = app;
+        return from(
+            this.appModuleBootstrap(app).then(appModuleRef => {
+                this.appModuleRef = appModuleRef!;
+                this.appModuleRef.instance.appName = this.name;
+                this.syncPortalRouteWhenNavigationEnd();
+                return this;
+            })
+        );
+    }
+
+    getRouter() {
+        return this.appModuleRef?.injector.get(Router);
+    }
+
+    getCurrentRouterStateUrl() {
+        return this.getRouter()?.routerState.snapshot.url;
+    }
+
+    navigateByUrl(url: string): void {
+        const router = this.getRouter();
+        this.ngZone?.run(() => {
+            router?.navigateByUrl(url);
+        });
+    }
+
+    getComponentFactory() {
+        return this.componentFactory;
+    }
+
+    registerComponentFactory(componentFactory: PlantComponentFactory) {
+        this.componentFactory = componentFactory;
+    }
+
+    destroy(): void {
+        if (this.appModuleRef) {
+            const router = this.appModuleRef.injector.get(Router);
+            if (router) {
+                router.dispose();
+            }
+            if (this.sandbox) {
+                this.sandbox.destroy();
+            }
+            this.appModuleRef.destroy();
+            this.appModuleRef = undefined;
+        }
+    }
+}

package/packages/planet/src/application/planet-application.service.spec.ts

@@ -0,0 +1,145 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { PlanetApplicationService } from './planet-application.service';
+import { SwitchModes } from '../planet.class';
+import { HttpClient } from '@angular/common/http';
+import { app1, app2, app2WithPreload } from '../testing/applications';
+import { AssetsLoader } from 'ngx-planet/assets-loader';
+import { Planet } from 'ngx-planet/planet';
+
+describe('PlanetApplicationService', () => {
+    let planetApplicationService: PlanetApplicationService;
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [HttpClientTestingModule],
+            providers: []
+        });
+        planetApplicationService = TestBed.inject(PlanetApplicationService);
+    });
+
+    it(`should throw error when repeat PlanetApplicationService injection`, () => {
+        window['planet'].applicationService = TestBed.inject(PlanetApplicationService);
+        expect(() => {
+            return new PlanetApplicationService(TestBed.inject(HttpClient), TestBed.inject(AssetsLoader));
+        }).toThrowError('PlanetApplicationService has been injected in the portal, repeated injection is not allowed');
+        window['planet'].applicationService = null;
+    });
+
+    describe('register', () => {
+        it('should register signal app1 success', () => {
+            planetApplicationService.register(app1);
+            expect(planetApplicationService.getApps()).toEqual([app1]);
+        });
+
+        it('should throw error when register exist app1 ', () => {
+            planetApplicationService.register(app1);
+            expect(() => {
+                planetApplicationService.register(app1);
+            }).toThrowError('app1 has be registered.');
+        });
+
+        it('should register multiple apps contains app1 and app2 success', () => {
+            planetApplicationService.register([app1, app2]);
+            expect(planetApplicationService.getApps()).toEqual([app1, app2]);
+        });
+
+        describe('registerByUrl', () => {
+            let httpClient: HttpClient;
+            let httpTestingController: HttpTestingController;
+            beforeEach(() => {
+                httpClient = TestBed.inject(HttpClient);
+                httpTestingController = TestBed.inject(HttpTestingController);
+            });
+
+            afterEach(() => {
+                // After every test, assert that there are no more pending requests.
+                httpTestingController.verify();
+            });
+
+            it('should register multiple apps by url', () => {
+                planetApplicationService.registerByUrl('/static/apps.json');
+                const req = httpTestingController.expectOne('/static/apps.json');
+
+                // Assert that the request is a GET.
+                expect(req.request.method).toEqual('GET');
+
+                // Respond with mock data, causing Observable to resolve.
+                // Subscribe callback asserts that correct data was returned.
+                req.flush([app1, app2]);
+
+                expect(planetApplicationService.getApps()).toEqual([app1, app2]);
+            });
+
+            it('should register one app by url', () => {
+                planetApplicationService.registerByUrl('/static/apps.json');
+                const req = httpTestingController.expectOne('/static/apps.json');
+                expect(req.request.method).toEqual('GET');
+                req.flush(app1);
+                expect(planetApplicationService.getApps()).toEqual([app1]);
+            });
+        });
+    });
+
+    describe('unregister', () => {
+        it('should unregister app1 success', () => {
+            planetApplicationService.register(app1);
+            expect(planetApplicationService.getApps()).toEqual([app1]);
+            planetApplicationService.unregister(app1.name);
+            expect(planetApplicationService.getApps()).toEqual([]);
+        });
+    });
+
+    describe('getAppsByMatchedUrl', () => {
+        it('should get matched apps(app1) by url app1/dashboard', () => {
+            planetApplicationService.register(app1);
+            planetApplicationService.register(app2);
+            const apps = planetApplicationService.getAppsByMatchedUrl('/app1/dashboard');
+            expect(apps).toEqual([app1]);
+        });
+
+        it('should get matched apps by url when apps has same routerPathPrefix', () => {
+            planetApplicationService.register(app1);
+            const app2SameApp1 = { ...app2, routerPathPrefix: '/app1' };
+            planetApplicationService.register(app2SameApp1);
+            const apps = planetApplicationService.getAppsByMatchedUrl('/app1/dashboard');
+            expect(apps).toEqual([app1, app2SameApp1]);
+        });
+
+        it('should get empty apps by url __/dashboard/app1 without start with app1', () => {
+            planetApplicationService.register(app1);
+            planetApplicationService.register(app2);
+            const apps = planetApplicationService.getAppsByMatchedUrl('/__/dashboard/app1');
+            expect(apps).toEqual([]);
+        });
+
+        it('should get matched apps which rule is RegExp("(a\\wp3)|app4") by url app3/dashboard', () => {
+            planetApplicationService.register(app1);
+            planetApplicationService.register(app2);
+            const app3 = {
+                ...app1,
+                name: 'app3',
+                routerPathPrefix: new RegExp('(a\\wp3)|app4')
+            };
+            planetApplicationService.register(app3);
+            const apps = planetApplicationService.getAppsByMatchedUrl('/app3/dashboard');
+            expect(apps).toBeTruthy('app is not found');
+            expect(apps[0]).toBe(app3);
+        });
+    });
+
+    describe('getAppsToPreload', () => {
+        it('should get correct preload apps', () => {
+            planetApplicationService.register(app1);
+            planetApplicationService.register(app2WithPreload);
+            const appsToPreload = planetApplicationService.getAppsToPreload();
+            expect(appsToPreload).toEqual([app2WithPreload]);
+        });
+
+        it('should get correct preload apps exclude app names', () => {
+            planetApplicationService.register(app1);
+            planetApplicationService.register(app2WithPreload);
+            const appsToPreload = planetApplicationService.getAppsToPreload(['app2']);
+            expect(appsToPreload).toEqual([]);
+        });
+    });
+});

package/packages/planet/src/application/planet-application.service.ts

@@ -0,0 +1,88 @@
+import { PlanetApplication } from '../planet.class';
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { shareReplay, map } from 'rxjs/operators';
+import { coerceArray } from '../helpers';
+import { Observable } from 'rxjs';
+import { AssetsLoader } from '../assets-loader';
+import { getApplicationService } from '../global-planet';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class PlanetApplicationService {
+    private apps: PlanetApplication[] = [];
+
+    private appsMap: { [key: string]: PlanetApplication } = {};
+
+    constructor(private http: HttpClient, private assetsLoader: AssetsLoader) {
+        if (getApplicationService()) {
+            throw new Error(
+                'PlanetApplicationService has been injected in the portal, repeated injection is not allowed'
+            );
+        }
+    }
+
+    register<TExtra>(appOrApps: PlanetApplication<TExtra> | PlanetApplication<TExtra>[]) {
+        const apps = coerceArray(appOrApps);
+        apps.forEach(app => {
+            if (this.appsMap[app.name]) {
+                throw new Error(`${app.name} has be registered.`);
+            }
+            this.apps.push(app);
+            this.appsMap[app.name] = app;
+        });
+    }
+
+    registerByUrl(url: string): Observable<void> {
+        const result = this.http.get(`${url}`).pipe(
+            map(apps => {
+                if (apps && Array.isArray(apps)) {
+                    this.register(apps);
+                } else {
+                    this.register(apps as PlanetApplication);
+                }
+            }),
+            shareReplay()
+        );
+        result.subscribe();
+        return result;
+    }
+
+    unregister(name: string) {
+        if (this.appsMap[name]) {
+            delete this.appsMap[name];
+            this.apps = this.apps.filter(app => {
+                return app.name !== name;
+            });
+        }
+    }
+
+    getAppsByMatchedUrl<TExtra = unknown>(url: string): PlanetApplication<TExtra>[] {
+        return this.getApps().filter(app => {
+            if (app.routerPathPrefix instanceof RegExp) {
+                return app.routerPathPrefix.test(url);
+            } else {
+                return url.startsWith(app.routerPathPrefix);
+            }
+        });
+    }
+
+    getAppByName(name: string) {
+        return this.appsMap[name];
+    }
+
+    getAppsToPreload(excludeAppNames?: string[]) {
+        return this.getApps().filter(app => {
+            if (excludeAppNames) {
+                return app.preload && !excludeAppNames.includes(app.name);
+            } else {
+                return app.preload;
+            }
+        });
+    }
+
+    getApps() {
+        return this.apps;
+    }
+}

package/packages/planet/src/application/portal-application.spec.ts

@@ -0,0 +1,53 @@
+import { TestBed } from '@angular/core/testing';
+import { Router } from '@angular/router';
+import { PlanetPortalApplication } from './portal-application';
+import { NgZone, ApplicationRef } from '@angular/core';
+import { RouterTestingModule } from '@angular/router/testing';
+
+describe('PlanetPortalApplication', () => {
+    let router: Router;
+    let planetPortalApplication: PlanetPortalApplication;
+    beforeEach(() => {
+        TestBed.configureTestingModule({
+            imports: [RouterTestingModule.withRoutes([])]
+        });
+        router = TestBed.inject(Router);
+        planetPortalApplication = new PlanetPortalApplication();
+        planetPortalApplication.ngZone = TestBed.inject(NgZone);
+        planetPortalApplication.applicationRef = TestBed.inject(ApplicationRef);
+        planetPortalApplication.router = TestBed.inject(Router);
+    });
+
+    it(`should create PlanetPortalApplication`, () => {
+        expect(planetPortalApplication).toBeTruthy();
+    });
+
+    it(`should run function`, () => {
+        const spy = jasmine.createSpy('spy');
+        expect(spy).not.toHaveBeenCalled();
+        planetPortalApplication.run(spy);
+        expect(spy).toHaveBeenCalled();
+    });
+
+    it(`should run function in ngZone`, () => {
+        const ngZoneRunSpy = spyOn(planetPortalApplication.ngZone, 'run');
+        expect(ngZoneRunSpy).not.toHaveBeenCalled();
+        planetPortalApplication.run(() => {});
+        expect(ngZoneRunSpy).toHaveBeenCalled();
+    });
+
+    it(`should run tick`, () => {
+        const tickSpy = spyOn(planetPortalApplication.applicationRef, 'tick');
+        expect(tickSpy).not.toHaveBeenCalled();
+        planetPortalApplication.tick();
+        expect(tickSpy).toHaveBeenCalled();
+    });
+
+    it(`should run navigateByUrl`, () => {
+        const navigateByUrlSpy = spyOn(planetPortalApplication.router, 'navigateByUrl');
+        expect(navigateByUrlSpy).not.toHaveBeenCalled();
+        planetPortalApplication.navigateByUrl('/app1/dashboard', { skipLocationChange: true });
+        expect(navigateByUrlSpy).toHaveBeenCalled();
+        expect(navigateByUrlSpy).toHaveBeenCalledWith('/app1/dashboard', { skipLocationChange: true });
+    });
+});

package/packages/planet/src/application/portal-application.ts

@@ -0,0 +1,28 @@
+import { Router, UrlTree, NavigationExtras } from '@angular/router';
+import { NgZone, Injector, ApplicationRef } from '@angular/core';
+import { GlobalEventDispatcher } from '../global-event-dispatcher';
+
+export class PlanetPortalApplication<TData = any> {
+    applicationRef?: ApplicationRef;
+    injector?: Injector;
+    router?: Router;
+    ngZone?: NgZone;
+    globalEventDispatcher?: GlobalEventDispatcher;
+    data?: TData;
+
+    navigateByUrl(url: string | UrlTree, extras?: NavigationExtras): Promise<boolean> {
+        return this.ngZone!.run(() => {
+            return this.router!.navigateByUrl(url, extras);
+        });
+    }
+
+    run<T>(fn: (...args: any[]) => T): T {
+        return this.ngZone!.run<T>(() => {
+            return fn();
+        });
+    }
+
+    tick() {
+        this.applicationRef!.tick();
+    }
+}