@worktile/planet 12.1.1 → 14.0.0-next.0

package/packages/planet/src/debug.ts

@@ -1,66 +0,0 @@
-import { isFunction } from './helpers';
-
-export interface Debugger {
-    (formatter: any, ...args: any[]): void;
-
-    // color: string;
-    // enabled: boolean;
-    // log: (...args: any[]) => any;
-    // namespace: string;
-    // destroy: () => boolean;
-    // extend: (namespace: string, delimiter?: string) => Debugger;
-}
-
-export interface Formatters {
-    [formatter: string]: (v: any) => string;
-}
-
-export interface Debug {
-    (namespace: string): Debugger;
-    coerce: (val: any) => any;
-    disable: () => string;
-    enable: (namespaces: string) => void;
-    enabled: (namespaces: string) => boolean;
-    log: (...args: any[]) => any;
-
-    names: RegExp[];
-    skips: RegExp[];
-
-    formatters: Formatters;
-}
-
-/**
- * Debug factory for debug module
- */
-let _debugFactory: Debug | undefined;
-let _debuggerMap: Record<string, Debugger> = {};
-
-export function createDebug(namespace: string): Debugger {
-    const key = `planet:${namespace}`;
-    return function(formatter: any, ...args: any[]) {
-        if (_debugFactory) {
-            let debugDebugger = _debuggerMap[key];
-            if (!debugDebugger) {
-                debugDebugger = _debugFactory(key);
-                _debuggerMap[key] = debugDebugger;
-            }
-            debugDebugger(formatter, args);
-        }
-    };
-}
-
-export function setDebugFactory(debug: Debug) {
-    if (debug && !isFunction(debug)) {
-        throw new Error('debug factory type is invalid, must be function');
-    }
-    _debugFactory = debug;
-}
-
-export function clearDebugFactory() {
-    _debugFactory = undefined;
-    _debuggerMap = {};
-}
-
-export function getDebugFactory() {
-    return _debugFactory;
-}

package/packages/planet/src/empty/empty.component.spec.ts

@@ -1,34 +0,0 @@
-import { TestBed, ComponentFixture } from '@angular/core/testing';
-import { NgxPlanetModule } from '../module';
-import { Component } from '@angular/core';
-import { By } from '@angular/platform-browser';
-import { EmptyComponent } from './empty.component';
-
-@Component({
-    selector: 'empty-component-basic',
-    template: '<empty-component></empty-component>'
-})
-class EmptyComponentBasicComponent {}
-
-describe('empty-component', () => {
-    let fixture: ComponentFixture<EmptyComponentBasicComponent>;
-    beforeEach(() => {
-        TestBed.configureTestingModule({
-            declarations: [EmptyComponentBasicComponent],
-            imports: [NgxPlanetModule]
-        });
-        fixture = TestBed.createComponent(EmptyComponentBasicComponent);
-        TestBed.compileComponents();
-    });
-
-    it(`should create empty component`, () => {
-        const emptyComponentDebugElement = fixture.debugElement.query(By.directive(EmptyComponent));
-        expect(emptyComponentDebugElement).toBeTruthy();
-        expect(emptyComponentDebugElement.componentInstance).toBeTruthy();
-    });
-
-    it(`should content is empty in empty component`, () => {
-        const emptyComponentDebugElement = fixture.debugElement.query(By.directive(EmptyComponent));
-        expect((emptyComponentDebugElement.nativeElement as HTMLElement).children.length).toBe(0);
-    });
-});

package/packages/planet/src/empty/empty.component.ts

@@ -1,7 +0,0 @@
-import { Component } from '@angular/core';
-
-@Component({
-    selector: 'empty-component',
-    template: ``
-})
-export class EmptyComponent {}

package/packages/planet/src/global-event-dispatcher.spec.ts

@@ -1,81 +0,0 @@
-import { GlobalEventDispatcher } from './global-event-dispatcher';
-import { NgZone } from '@angular/core';
-import { TestBed, inject } from '@angular/core/testing';
-import { CommonModule } from '@angular/common';
-import { Subject } from 'rxjs';
-import { takeUntil } from 'rxjs/operators';
-
-describe('GlobalEventDispatcher', () => {
-    let ngZone: NgZone;
-    let globalEventDispatcher: GlobalEventDispatcher;
-    beforeEach(() => {
-        TestBed.configureTestingModule({
-            imports: [CommonModule]
-        });
-    });
-
-    beforeEach(inject(
-        [NgZone, GlobalEventDispatcher],
-        (_ngZone: NgZone, _globalEventDispatcher: GlobalEventDispatcher) => {
-            ngZone = _ngZone;
-            globalEventDispatcher = _globalEventDispatcher;
-        }
-    ));
-
-    it(`should create GlobalEventDispatcher`, () => {
-        expect(globalEventDispatcher).toBeTruthy();
-    });
-
-    it(`should register event success`, () => {
-        const testEventSpy = jasmine.createSpy('test-event spy');
-        const addEventListenerApy = spyOn(window, 'addEventListener');
-        expect(addEventListenerApy).not.toHaveBeenCalled();
-        expect(globalEventDispatcher.getSubscriptionCount()).toEqual(0);
-        globalEventDispatcher.register('test-event').subscribe(testEventSpy);
-        expect(globalEventDispatcher.getSubscriptionCount()).toEqual(1);
-        expect(testEventSpy).not.toHaveBeenCalled();
-        expect(addEventListenerApy).toHaveBeenCalled();
-    });
-
-    it(`should remove event listener when unsubscribe event success`, () => {
-        const unsubscribe$ = new Subject();
-        const removeEventListenerSpy = spyOn(window, 'removeEventListener');
-        globalEventDispatcher
-            .register('test-event')
-            .pipe(takeUntil(unsubscribe$))
-            .subscribe();
-        expect(removeEventListenerSpy).not.toHaveBeenCalled();
-        expect(globalEventDispatcher.getSubscriptionCount()).toEqual(1);
-        unsubscribe$.next();
-        unsubscribe$.complete();
-        expect(removeEventListenerSpy).toHaveBeenCalled();
-        expect(globalEventDispatcher.getSubscriptionCount()).toEqual(0);
-    });
-
-    it(`should run in ngZone when dispatch event`, () => {
-        const ngZoneRunSpy = spyOn(ngZone, 'run');
-        const testEventSpy = jasmine.createSpy('test-event spy');
-        globalEventDispatcher.register('test-event').subscribe(testEventSpy);
-        expect(testEventSpy).not.toHaveBeenCalled();
-        expect(ngZoneRunSpy).not.toHaveBeenCalled();
-        globalEventDispatcher.dispatch('test-event');
-        expect(ngZoneRunSpy).toHaveBeenCalled();
-    });
-
-    it(`should dispatch event success`, () => {
-        const testEventSpy = jasmine.createSpy('test-event spy');
-        globalEventDispatcher.register('test-event').subscribe(testEventSpy);
-        expect(testEventSpy).not.toHaveBeenCalled();
-        globalEventDispatcher.dispatch('test-event');
-        expect(testEventSpy).toHaveBeenCalled();
-    });
-
-    it(`should dispatch event with parameters success`, () => {
-        const testEventSpy = jasmine.createSpy('test-event spy');
-        globalEventDispatcher.register('test-event').subscribe(testEventSpy);
-        expect(testEventSpy).not.toHaveBeenCalled();
-        globalEventDispatcher.dispatch('test-event', 'test-event-payload');
-        expect(testEventSpy).toHaveBeenCalled();
-        expect(testEventSpy).toHaveBeenCalledWith('test-event-payload');
-    });
-});

package/packages/planet/src/global-event-dispatcher.ts

@@ -1,82 +0,0 @@
-import { Subject, Observable } from 'rxjs';
-import { filter, map } from 'rxjs/operators';
-import { Injectable, NgZone } from '@angular/core';
-
-export interface GlobalDispatcherEvent {
-    name: string;
-    payload: any;
-}
-
-const CUSTOM_EVENT_NAME = 'PLANET_GLOBAL_EVENT_DISPATCHER';
-
-@Injectable({
-    providedIn: 'root'
-})
-export class GlobalEventDispatcher {
-    private subject$: Subject<GlobalDispatcherEvent> = new Subject();
-
-    private hasAddGlobalEventListener = false;
-
-    private subscriptionCount = 0;
-
-    private globalEventListener = (event: CustomEvent) => {
-        this.subject$.next(event.detail);
-    };
-
-    private addGlobalEventListener() {
-        this.hasAddGlobalEventListener = true;
-        window.addEventListener(CUSTOM_EVENT_NAME, this.globalEventListener);
-    }
-
-    private removeGlobalEventListener() {
-        this.hasAddGlobalEventListener = false;
-        window.removeEventListener(CUSTOM_EVENT_NAME, this.globalEventListener);
-    }
-
-    constructor(private ngZone: NgZone) {}
-
-    dispatch<TPayload>(name: string, payload?: TPayload) {
-        window.dispatchEvent(
-            new CustomEvent(CUSTOM_EVENT_NAME, {
-                detail: {
-                    name: name,
-                    payload: payload
-                }
-            })
-        );
-    }
-
-    register<T>(eventName: string): Observable<T> {
-        return new Observable(observer => {
-            if (!this.hasAddGlobalEventListener) {
-                this.addGlobalEventListener();
-            }
-            this.subscriptionCount++;
-            const subscription = this.subject$
-                .pipe(
-                    filter(event => {
-                        return event.name === eventName;
-                    }),
-                    map(event => {
-                        return event.payload;
-                    })
-                )
-                .subscribe(payload => {
-                    this.ngZone.run(() => {
-                        observer.next(payload);
-                    });
-                });
-            return () => {
-                this.subscriptionCount--;
-                subscription.unsubscribe();
-                if (!this.subscriptionCount) {
-                    this.removeGlobalEventListener();
-                }
-            };
-        });
-    }
-
-    getSubscriptionCount() {
-        return this.subscriptionCount;
-    }
-}

package/packages/planet/src/global-planet.spec.ts

@@ -1,39 +0,0 @@
-import { defineApplication, clearGlobalPlanet } from './global-planet';
-import { PlanetPortalApplication } from './application/portal-application';
-
-describe('defineApplication', () => {
-    afterEach(() => {
-        clearGlobalPlanet();
-    });
-
-    it('should define application success', () => {
-        defineApplication('app1', {
-            template: '<app1-root></app1-root>',
-            bootstrap: (portalApp?: PlanetPortalApplication) => {
-                return new Promise(() => {});
-            }
-        });
-        expect(window['planet'].apps['app1']).toBeTruthy();
-    });
-
-    it('should define application compatible success', () => {
-        defineApplication('app1', (portalApp?: PlanetPortalApplication) => {
-            return new Promise(() => {});
-        });
-        expect(window['planet'].apps['app1']).toBeTruthy();
-    });
-
-    it('should throw error when define application has exist', () => {
-        defineApplication('app1', {
-            template: '<app1-root></app1-root>',
-            bootstrap: (portalApp?: PlanetPortalApplication) => {
-                return new Promise(() => {});
-            }
-        });
-        expect(() => {
-            defineApplication('app1', (portalApp?: PlanetPortalApplication) => {
-                return new Promise(() => {});
-            });
-        }).toThrowError('app1 application has exist.');
-    });
-});

package/packages/planet/src/global-planet.ts

@@ -1,73 +0,0 @@
-import { PlanetApplicationRef, BootstrapAppModule, BootstrapOptions } from './application/planet-application-ref';
-import { PlanetPortalApplication } from './application/portal-application';
-import { PlanetApplicationLoader } from './application/planet-application-loader';
-import { PlanetApplicationService } from './application/planet-application.service';
-import { isFunction } from './helpers';
-
-declare const window: any;
-
-export interface GlobalPlanet {
-    apps: { [key: string]: PlanetApplicationRef };
-    portalApplication?: PlanetPortalApplication;
-    applicationLoader: PlanetApplicationLoader;
-    applicationService: PlanetApplicationService;
-}
-
-export const globalPlanet: GlobalPlanet = (window.planet = window.planet || {
-    apps: {}
-});
-
-export function defineApplication(name: string, options: BootstrapAppModule | BootstrapOptions) {
-    if (globalPlanet.apps[name]) {
-        throw new Error(`${name} application has exist.`);
-    }
-    if (isFunction(options)) {
-        options = {
-            template: '',
-            bootstrap: options as BootstrapAppModule
-        };
-    }
-    const appRef = new PlanetApplicationRef(name, options as BootstrapOptions);
-    globalPlanet.apps[name] = appRef;
-}
-
-export function getPlanetApplicationRef(appName: string): PlanetApplicationRef | null {
-    if (globalPlanet && globalPlanet.apps && globalPlanet.apps[appName]) {
-        return globalPlanet.apps[appName];
-    } else {
-        return null;
-    }
-}
-
-export function setPortalApplicationData<T>(data: T) {
-    if (globalPlanet.portalApplication) {
-        globalPlanet.portalApplication.data = data;
-    }
-}
-
-export function getPortalApplicationData<TData>(): TData {
-    return globalPlanet.portalApplication?.data as TData;
-}
-
-export function setApplicationLoader(loader: PlanetApplicationLoader) {
-    globalPlanet.applicationLoader = loader;
-}
-
-export function getApplicationLoader() {
-    return globalPlanet.applicationLoader;
-}
-
-export function setApplicationService(service: PlanetApplicationService) {
-    globalPlanet.applicationService = service;
-}
-
-export function getApplicationService() {
-    return globalPlanet.applicationService;
-}
-
-export function clearGlobalPlanet() {
-    window.planet.apps = {};
-    window.planet.portalApplication = null;
-    window.planet.applicationLoader = null;
-    window.planet.applicationService = null;
-}

package/packages/planet/src/helpers.spec.ts

@@ -1,242 +0,0 @@
-import {
-    hashCode,
-    isEmpty,
-    coerceArray,
-    getHTMLElement,
-    getResourceFileName,
-    buildResourceFilePath,
-    getScriptsAndStylesFullPaths,
-    getTagNameByTemplate,
-    createElementByTemplate
-} from './helpers';
-
-describe('helpers', () => {
-    describe('hashCode', () => {
-        it(`should get number hash code`, () => {
-            const result = hashCode('/scripts/main.js');
-            expect(result).toBeTruthy();
-            expect(typeof result === 'number').toBeTruthy();
-            expect(/\d{9}/.test(result.toString())).toBeTruthy();
-        });
-
-        it(`should get same hash code when input is same`, () => {
-            const result1 = hashCode('/scripts/main.js');
-            const result2 = hashCode('/scripts/main.js');
-            expect(result1).toEqual(result2);
-        });
-
-        it(`should get different hash code when input is different`, () => {
-            const result1 = hashCode('/scripts/main.js');
-            const result2 = hashCode('/scripts/main1.js');
-            expect(result1).not.toEqual(result2);
-        });
-    });
-
-    describe(`isEmpty`, () => {
-        it(`should is empty when value is undefined`, () => {
-            const result = isEmpty(undefined);
-            expect(result).toBe(true);
-        });
-
-        it(`should is empty when value is null`, () => {
-            const result = isEmpty(null);
-            expect(result).toBe(true);
-        });
-
-        it(`should is empty when value is 0`, () => {
-            const result = isEmpty(0);
-            expect(result).toBe(true);
-        });
-
-        it(`should is empty when value is false`, () => {
-            const result = isEmpty(false);
-            expect(result).toBe(true);
-        });
-
-        it(`should is not empty when value is true`, () => {
-            const result = isEmpty(true);
-            expect(result).toBe(false);
-        });
-
-        it(`should is empty when value is empty array`, () => {
-            const result = isEmpty([]);
-            expect(result).toBe(true);
-        });
-
-        it(`should is not empty when value is not empty array`, () => {
-            const result = isEmpty([1]);
-            expect(result).toBe(false);
-        });
-
-        it(`should is not empty when value is number`, () => {
-            const result = isEmpty(1);
-            expect(result).toBe(false);
-        });
-
-        it(`should is not empty when value is object`, () => {
-            const result = isEmpty({});
-            expect(result).toBe(false);
-        });
-    });
-
-    describe('coerceArray', () => {
-        it('should wrap a string in an array', () => {
-            const stringVal = 'just a string';
-            expect(coerceArray(stringVal)).toEqual([stringVal]);
-        });
-
-        it('should wrap a number in an array', () => {
-            const numberVal = 42;
-            expect(coerceArray(numberVal)).toEqual([numberVal]);
-        });
-
-        it('should wrap an object in an array', () => {
-            const objectVal = { something: 'clever' };
-            expect(coerceArray(objectVal)).toEqual([objectVal]);
-        });
-
-        it('should wrap a null value in an array', () => {
-            const nullVal = null;
-            expect(coerceArray(nullVal)).toEqual([nullVal]);
-        });
-
-        it('should wrap an undefined value in an array', () => {
-            const undefinedVal = undefined;
-            expect(coerceArray(undefinedVal)).toEqual([undefinedVal]);
-        });
-
-        it('should not wrap an array in an array', () => {
-            const arrayVal = [1, 2, 3];
-            expect(coerceArray(arrayVal)).toBe(arrayVal);
-        });
-    });
-
-    describe('getHTMLElement', () => {
-        it('should get HTMLElement when input is HTMLElement', () => {
-            const htmlElement = document.createElement('div');
-            const result = getHTMLElement(htmlElement);
-            expect(result).toBe(htmlElement);
-        });
-
-        it('should call document querySelector when input is not HTMLElement', () => {
-            const querySelectorSpy = spyOn(document, 'querySelector');
-            expect(querySelectorSpy).toHaveBeenCalledTimes(0);
-            getHTMLElement('.span');
-            expect(querySelectorSpy).toHaveBeenCalledTimes(1);
-            expect(querySelectorSpy).toHaveBeenCalledWith('.span');
-        });
-    });
-
-    describe(`createElementByTemplate`, () => {
-        it('should create html element success', () => {
-            const element = createElementByTemplate(`<app1-root class='app1-root'></app1-root>`);
-            expect(element.outerHTML).toBe(`<app1-root class="app1-root"></app1-root>`);
-        });
-
-        it('should create html element when template invalid', () => {
-            expect(() => {
-                createElementByTemplate(`app1-root`);
-            }).toThrowError(`invalid template 'app1-root'`);
-        });
-
-        it('should create html element when template is empty', () => {
-            const element = createElementByTemplate(``);
-            expect(element).toBe(null);
-        });
-    });
-
-    describe(`getTagNameByTemplate`, () => {
-        it('should get tagName is APP1-ROOT', () => {
-            const tagName = getTagNameByTemplate(`<app1-root></app1-root>`);
-            expect(tagName).toBe('APP1-ROOT');
-        });
-
-        it('should get tagName when template is empty', () => {
-            const tagName = getTagNameByTemplate(``);
-            expect(tagName).toBe('');
-        });
-    });
-
-    describe('getResourceFileName', () => {
-        it('should get original path when path is "file.js"', () => {
-            const path = 'file.js';
-            const result = getResourceFileName(path);
-            expect(result).toBe(path);
-        });
-
-        it('should get correct path when path is "assets/file.js"', () => {
-            const path = 'assets/file.js';
-            const result = getResourceFileName(path);
-            expect(result).toBe('file.js');
-        });
-    });
-
-    describe('buildResourceFilePath', () => {
-        it('should get correct path input "main.js"', () => {
-            const result = buildResourceFilePath('main.js', { 'main.js': 'main.h2d3f2232.js' });
-            expect(result).toBe('main.h2d3f2232.js');
-        });
-
-        it('should get correct path when input "main.js" which has not exist in manifest', () => {
-            const result = buildResourceFilePath('main.js', {});
-            expect(result).toBe('main.js');
-        });
-
-        it('should get correct path input "assets/scripts/main.js"', () => {
-            const result = buildResourceFilePath('assets/scripts/main.js', { 'main.js': 'main.h2d3f2232.js' });
-            expect(result).toBe('assets/scripts/main.h2d3f2232.js');
-        });
-    });
-
-    describe('getScriptsAndStylesFullPaths', () => {
-        const app = {
-            name: 'app1',
-            hostParent: '.host-selector',
-            selector: 'app1-root',
-            routerPathPrefix: '/app1',
-            hostClass: 'app1-host',
-            preload: false,
-            // resourcePathPrefix: '/static/app1/',
-            styles: ['styles/main.css'],
-            scripts: ['vendor.js', 'main.js'],
-            extra: {
-                appName: '应用1'
-            }
-        };
-
-        it('should get correct full path without resourcePathPrefix', () => {
-            const result = getScriptsAndStylesFullPaths({ ...app });
-            expect(result).toEqual({
-                scripts: ['vendor.js', 'main.js'],
-                styles: ['styles/main.css']
-            });
-        });
-
-        it('should get correct full path with resourcePathPrefix', () => {
-            const result = getScriptsAndStylesFullPaths({ ...app, resourcePathPrefix: '/static/app1/' });
-            expect(result).toEqual({
-                scripts: ['/static/app1/vendor.js', '/static/app1/main.js'],
-                styles: ['/static/app1/styles/main.css']
-            });
-        });
-
-        it('should get correct full path with manifest', () => {
-            const manifest = {
-                'vendor.js': `vendor.${randomString()}.js`,
-                'main.js': `main.${randomString()}.js`,
-                'main.css': `main.${randomString()}.css`
-            };
-            const result = getScriptsAndStylesFullPaths({ ...app, resourcePathPrefix: '/static/app1/' }, manifest);
-            expect(result).toEqual({
-                scripts: [`/static/app1/${manifest['vendor.js']}`, `/static/app1/${manifest['main.js']}`],
-                styles: [`/static/app1/styles/${manifest['main.css']}`]
-            });
-        });
-    });
-});
-
-function randomString() {
-    return Math.random()
-        .toString(36)
-        .slice(-8);
-}