@worktile/planet 10.0.0 → 12.1.1

package/packages/planet/src/sandbox/proxy/types.ts

@@ -0,0 +1,20 @@
+import { Global } from '../types';
+
+// SandboxInstance  主要是为了解决循环依赖
+export interface ProxySandboxInstance {
+    app: string;
+
+    running: boolean;
+
+    global: Global;
+
+    rewriteVariables: PropertyKey[];
+}
+
+export interface SandboxPatchHandler {
+    rewrite?: Record<PropertyKey, any>;
+    init?: () => void;
+    destroy?: () => void;
+}
+
+export type SandboxPatch = (sandbox?: ProxySandboxInstance) => SandboxPatchHandler;

package/packages/planet/src/sandbox/sandbox.ts

@@ -0,0 +1,20 @@
+import { execScript } from './exec';
+import { Global } from './types';
+
+export interface SandboxOptions {
+    strictGlobal?: boolean;
+}
+
+export abstract class Sandbox {
+    options!: SandboxOptions;
+
+    global!: Global;
+
+    abstract start(): void;
+
+    abstract destroy(): void;
+
+    execScript(code: string, url = '') {
+        execScript(code, url, this.global, !!this.options.strictGlobal);
+    }
+}

package/packages/planet/src/sandbox/snapshot/snapshot-sandbox.ts

@@ -0,0 +1,12 @@
+import { Sandbox, SandboxOptions } from '../sandbox';
+
+export class SnapshotSandbox extends Sandbox {
+    constructor(public app: string, public options: SandboxOptions) {
+        super();
+        this.start();
+    }
+
+    start() {}
+
+    destroy() {}
+}

package/packages/planet/src/sandbox/types.ts

@@ -0,0 +1 @@
+export type Global = Record<PropertyKey, any>;

package/packages/planet/src/test.ts

@@ -0,0 +1,16 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+// import 'core-js/es7/reflect';
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed } from '@angular/core/testing';
+import { BrowserDynamicTestingModule, platformBrowserDynamicTesting } from '@angular/platform-browser-dynamic/testing';
+
+declare const require: any;
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting());
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/packages/planet/src/testing/app1.module.ts

@@ -0,0 +1,34 @@
+import { Component, NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { PlanetComponentLoader } from '../component/planet-component-loader';
+import { PlanetApplicationLoader } from '../application/planet-application-loader';
+
+export const app1Name = 'app1';
+
+@Component({
+    selector: 'app1-projects',
+    template: `
+        projects is work
+    `
+})
+export class App1ProjectsComponent {}
+
+@NgModule({
+    declarations: [App1ProjectsComponent],
+    entryComponents: [App1ProjectsComponent],
+    imports: [RouterModule.forChild([])],
+    providers: [
+        PlanetComponentLoader,
+        {
+            provide: PlanetApplicationLoader,
+            useValue: {
+                preload: () => {}
+            }
+        }
+    ]
+})
+export class App1Module {
+    constructor(private componentLoader: PlanetComponentLoader) {
+        // componentLoader.register([{ name: 'app1-projects', component: App1ProjectsComponent }]);
+    }
+}

package/packages/planet/src/testing/app2.module.ts

@@ -0,0 +1,24 @@
+import { Component, NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { PlanetApplicationLoader } from '../application/planet-application-loader';
+import { PlanetComponentLoader } from '../component/planet-component-loader';
+
+export const app2Name = 'app2';
+
+@NgModule({
+    declarations: [],
+    entryComponents: [],
+    imports: [RouterModule.forChild([])],
+    providers: [
+        PlanetComponentLoader,
+        {
+            provide: PlanetApplicationLoader,
+            useValue: {
+                preload: () => {}
+            }
+        }
+    ]
+})
+export class App2Module {
+    constructor() {}
+}

package/packages/planet/src/testing/applications.ts

@@ -0,0 +1,58 @@
+import { SwitchModes } from '../planet.class';
+const app1 = {
+    name: 'app1',
+    hostParent: '.host-selector',
+    selector: 'app1-root',
+    stylePrefix: 'app1-prefix',
+    routerPathPrefix: '/app1',
+    hostClass: 'app1-host',
+    preload: false,
+    switchMode: SwitchModes.default,
+    resourcePathPrefix: '/static/app1/',
+    styles: ['styles/main.css'],
+    scripts: ['vendor.js', 'main.js'],
+    loadSerial: false,
+    manifest: '',
+    extra: {
+        appName: '应用1'
+    }
+};
+
+const app1WithManifest = {
+    ...app1,
+    manifest: '/static/app/manifest.json'
+};
+
+const app1WithPreload = {
+    ...app1,
+    preload: true
+};
+
+const app2 = {
+    name: 'app2',
+    hostParent: '.host-selector',
+    selector: 'app2-root',
+    routerPathPrefix: '/app2',
+    hostClass: 'app2-host',
+    preload: false,
+    switchMode: SwitchModes.coexist,
+    resourcePathPrefix: '/static/app2',
+    styles: ['styles/main.css'],
+    scripts: ['vendor.js', 'main.js'],
+    loadSerial: false,
+    extra: {
+        appName: '应用2'
+    }
+};
+
+const app2WithManifest = {
+    ...app2,
+    manifest: '/static/app/manifest.json'
+};
+
+const app2WithPreload = {
+    ...app2,
+    preload: true
+};
+
+export { app1, app1WithManifest, app1WithPreload, app2, app2WithManifest, app2WithPreload };

package/packages/planet/src/testing/index.ts

@@ -0,0 +1,2 @@
+export * from './applications';
+export * from './utils';

package/packages/planet/src/testing/utils.ts

@@ -0,0 +1,31 @@
+import { setDebugFactory, clearDebugFactory } from '../debug';
+
+export function roundNumber(minNum: number, maxNum?: number): number {
+    switch (arguments.length) {
+        case 1:
+            return parseInt((Math.random() * minNum + 1) as any, 10);
+        case 2:
+            return parseInt((Math.random() * (maxNum! - minNum + 1) + minNum) as any, 10);
+        default:
+            return 0;
+    }
+}
+
+export function sample<T>(items: T[]): T {
+    const num = roundNumber(1, items.length);
+    return items[num - 1];
+}
+
+export function enableDebugForTest() {
+    const debugFactory = (namespace: string) => {
+        return (formatter: string) => {
+            console.log(`[${namespace}] ${formatter}`);
+        };
+    };
+
+    setDebugFactory(debugFactory as any);
+}
+
+export function disableDebugForTest() {
+    clearDebugFactory();
+}

package/packages/planet/tsconfig.lib.json

@@ -0,0 +1,27 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declarationMap": true,
+    "target": "es2015",
+    "module": "es2015",
+    "moduleResolution": "node",
+    "declaration": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "types": [],
+    "lib": ["dom", "es2018"]
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true,
+    "enableResourceInlining": true,
+    "enableIvy": false
+  },
+  "exclude": ["src/test.ts", "**/*.spec.ts"]
+}

package/packages/planet/tsconfig.lib.prod.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/packages/planet/tsconfig.spec.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine",
+      "node"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/packages/planet/tslint.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tslint.json",
+  "rules": {
+    "directive-selector": [true, "attribute", "lib", "camelCase"],
+    "component-selector": [true, "element", "empty", "kebab-case"]
+  }
+}

package/postcss.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    plugins: [require('autoprefixer')]
+};

package/proxy.conf.js

@@ -0,0 +1,15 @@
+const PROXY_CONFIG = {};
+
+PROXY_CONFIG['/static/app1'] = {
+    target: 'http://localhost:3001',
+    secure: false,
+    changeOrigin: false
+};
+
+PROXY_CONFIG['/static/app2'] = {
+    target: 'http://localhost:3002',
+    secure: false,
+    changeOrigin: true
+};
+
+module.exports = PROXY_CONFIG;

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": false,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "target": "es5",
+    "typeRoots": ["node_modules/@types"],
+    "lib": ["es2018", "dom"],
+    "paths": {
+      "@demo/common": ["examples/common"],
+      "ngx-planet": ["packages/planet/src/public-api.ts"],
+      "ngx-planet/*": ["packages/planet/src/*"]
+    }
+  },
+  "angularCompilerOptions": {}
+}

package/tslint.json

@@ -0,0 +1,80 @@
+{
+  "rulesDirectory": ["codelyzer"],
+  "rules": {
+    "arrow-return-shorthand": true,
+    "callable-types": true,
+    "class-name": true,
+    "comment-format": [true, "check-space"],
+    "curly": true,
+    "deprecation": {
+      "severity": "warn"
+    },
+    "eofline": true,
+    "forin": true,
+    "import-blacklist": [true, "rxjs/Rx"],
+    "import-spacing": true,
+    "indent": [true, "spaces"],
+    "interface-over-type-literal": true,
+    "label-position": true,
+    "max-line-length": [true, 140],
+    "member-access": false,
+    "member-ordering": [
+      true,
+      {
+        "order": ["static-field", "instance-field", "static-method", "instance-method"]
+      }
+    ],
+    "no-arg": true,
+    "no-bitwise": false,
+    "no-console": [true, "debug", "info", "time", "timeEnd", "trace"],
+    "no-construct": true,
+    "no-debugger": true,
+    "no-duplicate-super": true,
+    "no-empty": false,
+    "no-empty-interface": true,
+    "no-eval": true,
+    "no-inferrable-types": [true, "ignore-params"],
+    "no-misused-new": true,
+    "no-non-null-assertion": true,
+    "no-redundant-jsdoc": true,
+    "no-shadowed-variable": true,
+    "no-string-literal": false,
+    "no-string-throw": true,
+    "no-switch-case-fall-through": true,
+    "no-trailing-whitespace": true,
+    "no-unnecessary-initializer": true,
+    "no-unused-expression": true,
+    "no-use-before-declare": true,
+    "no-var-keyword": true,
+    "object-literal-sort-keys": false,
+    "one-line": [true, "check-open-brace", "check-catch", "check-else", "check-whitespace"],
+    "prefer-const": true,
+    "quotemark": [true, "single"],
+    "radix": true,
+    "semicolon": [true, "always", "strict-bound-class-methods"],
+    "triple-equals": [true, "allow-null-check"],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "unified-signatures": true,
+    "variable-name": false,
+    "whitespace": [true, "check-branch", "check-decl", "check-operator", "check-separator", "check-type"],
+    "no-output-on-prefix": true,
+    "use-input-property-decorator": true,
+    "use-output-property-decorator": true,
+    "use-host-property-decorator": true,
+    "no-input-rename": true,
+    "no-output-rename": true,
+    "use-life-cycle-interface": true,
+    "use-pipe-transform-interface": true,
+    "component-class-suffix": true,
+    "directive-class-suffix": true
+  }
+}

package/application/planet-application-loader.d.ts

@@ -1,68 +0,0 @@
-import { NgZone, ApplicationRef, Injector } from '@angular/core';
-import { Observable } from 'rxjs';
-import { AssetsLoader } from '../assets-loader';
-import { PlanetApplication, PlanetRouterEvent, PlanetOptions } from '../planet.class';
-import { PlanetApplicationRef } from './planet-application-ref';
-import { PlanetApplicationService } from './planet-application.service';
-import { Router } from '@angular/router';
-export declare enum ApplicationStatus {
-    assetsLoading = 1,
-    assetsLoaded = 2,
-    bootstrapping = 3,
-    bootstrapped = 4,
-    active = 5,
-    loadError = 10
-}
-export interface AppsLoadingStartEvent {
-    shouldLoadApps: PlanetApplication[];
-    shouldUnloadApps: PlanetApplication[];
-}
-export interface AppStatusChangeEvent {
-    app: PlanetApplication;
-    status: ApplicationStatus;
-}
-export declare class PlanetApplicationLoader {
-    private assetsLoader;
-    private planetApplicationService;
-    private ngZone;
-    private firstLoad;
-    private startRouteChangeEvent;
-    private options;
-    private inProgressAppAssetsLoads;
-    private appsStatus;
-    private portalApp;
-    private routeChange$;
-    private appStatusChange$;
-    private appsLoadingStart$;
-    get appStatusChange(): Observable<AppStatusChangeEvent>;
-    get appsLoadingStart(): Observable<AppsLoadingStartEvent>;
-    loadingDone: boolean;
-    constructor(assetsLoader: AssetsLoader, planetApplicationService: PlanetApplicationService, ngZone: NgZone, router: Router, injector: Injector, applicationRef: ApplicationRef);
-    private setAppStatus;
-    private switchModeIsCoexist;
-    private errorHandler;
-    private takeOneStable;
-    private setLoadingDone;
-    private setupRouteChange;
-    private startLoadAppAssets;
-    private hideApp;
-    private showApp;
-    private destroyApp;
-    private bootstrapApp;
-    private getUnloadApps;
-    private unloadApps;
-    private preloadApps;
-    private ensurePreloadApps;
-    setOptions(options: Partial<PlanetOptions>): void;
-    /**
-     * reset route by current router
-     */
-    reroute(event: PlanetRouterEvent): void;
-    private preloadInternal;
-    /**
-     * Preload planet application
-     * @param app app
-     * @param immediate bootstrap on stable by default, setting immediate is true, it will bootstrap immediate
-     */
-    preload(app: PlanetApplication, immediate?: boolean): Observable<PlanetApplicationRef>;
-}

package/application/planet-application-ref.d.ts

@@ -1,32 +0,0 @@
-import { NgModuleRef } from '@angular/core';
-import { Router } from '@angular/router';
-import { Observable } from 'rxjs';
-import { PlanetPortalApplication } from './portal-application';
-import { PlantComponentConfig } from '../component/plant-component.config';
-import { PlanetComponentRef } from '../component/planet-component-ref';
-export interface BootstrapOptions {
-    template: string;
-    bootstrap: BootstrapAppModule;
-}
-export declare type BootstrapAppModule = (portalApp?: PlanetPortalApplication) => Promise<NgModuleRef<any>>;
-export declare type PlantComponentFactory = <TData, TComp>(componentName: string, config: PlantComponentConfig<TData>) => PlanetComponentRef<TComp>;
-export declare class PlanetApplicationRef {
-    appModuleRef: NgModuleRef<any>;
-    template: string;
-    private innerSelector;
-    get selector(): string;
-    get bootstrapped(): boolean;
-    private name;
-    private portalApp;
-    private appModuleBootstrap;
-    private componentFactory;
-    constructor(name: string, options: BootstrapOptions);
-    private syncPortalRouteWhenNavigationEnd;
-    bootstrap(app: PlanetPortalApplication): Observable<this>;
-    getRouter(): Router;
-    getCurrentRouterStateUrl(): string;
-    navigateByUrl(url: string): void;
-    getComponentFactory(): PlantComponentFactory;
-    registerComponentFactory(componentFactory: PlantComponentFactory): void;
-    destroy(): void;
-}

package/application/planet-application.service.d.ts

@@ -1,18 +0,0 @@
-import { PlanetApplication } from '../planet.class';
-import { HttpClient } from '@angular/common/http';
-import { Observable } from 'rxjs';
-import { AssetsLoader } from '../assets-loader';
-export declare class PlanetApplicationService {
-    private http;
-    private assetsLoader;
-    private apps;
-    private appsMap;
-    constructor(http: HttpClient, assetsLoader: AssetsLoader);
-    register<TExtra>(appOrApps: PlanetApplication<TExtra> | PlanetApplication<TExtra>[]): void;
-    registerByUrl(url: string): Observable<void>;
-    unregister(name: string): void;
-    getAppsByMatchedUrl<TExtra>(url: string): PlanetApplication<TExtra>[];
-    getAppByName(name: string): PlanetApplication<any>;
-    getAppsToPreload(excludeAppNames?: string[]): PlanetApplication<any>[];
-    getApps(): PlanetApplication<any>[];
-}

package/application/portal-application.d.ts

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

package/assets-loader.d.ts

@@ -1,23 +0,0 @@
-import { Observable } from 'rxjs';
-import { HttpClient } from '@angular/common/http';
-import { PlanetApplication } from './planet.class';
-export interface AssetsLoadResult {
-    src: string;
-    hashCode: number;
-    loaded: boolean;
-    status: string;
-}
-export declare class AssetsLoader {
-    private http;
-    private loadedSources;
-    constructor(http: HttpClient);
-    loadScript(src: string): Observable<AssetsLoadResult>;
-    loadStyle(src: string): Observable<AssetsLoadResult>;
-    loadScripts(sources: string[], serial?: boolean): Observable<AssetsLoadResult[]>;
-    loadStyles(sources: string[]): Observable<AssetsLoadResult[]>;
-    loadScriptsAndStyles(scripts?: string[], styles?: string[], serial?: boolean): Observable<[AssetsLoadResult[], AssetsLoadResult[]]>;
-    loadAppAssets(app: PlanetApplication): Observable<[AssetsLoadResult[], AssetsLoadResult[]]>;
-    loadManifest(url: string): Observable<{
-        [key: string]: string;
-    }>;
-}