@worktile/planet 12.1.1 → 14.0.0-next.0

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

@@ -1,233 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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 });
-    });
-});