@worktile/planet 11.0.0 → 12.1.2

package/fesm2015/worktile-planet.js

@@ -4,8 +4,8 @@ import * as i3 from '@angular/router';
 import { Router, NavigationEnd } from '@angular/router';
 import * as i1 from '@angular/common/http';
 import { HttpClient, HttpClientModule } from '@angular/common/http';
-import { map, concatAll, switchMap, take, shareReplay, filter, distinctUntilChanged, catchError, tap, share, startWith, delayWhen, finalize } from 'rxjs/operators';
-import { of, Observable, concat, forkJoin, from, Subject, timer } from 'rxjs';
+import { map, concatAll, switchMap, take, shareReplay, filter, distinctUntilChanged, catchError, tap, share, startWith, delayWhen } from 'rxjs/operators';
+import { Observable, of, concat, forkJoin, from, Subject, timer } from 'rxjs';
 import { PortalInjector, DomPortalOutlet, ComponentPortal } from '@angular/cdk/portal';
 import * as i1$1 from '@angular/common';
 import { DOCUMENT } from '@angular/common';
@@ -41,14 +41,14 @@ function getHTMLElement(selector) {
 }
 function getTagNameByTemplate(template) {
     const element = createElementByTemplate(template);
-    return element ? element.nodeName : null;
+    return element ? element.nodeName : '';
 }
 function createElementByTemplate(template) {
     if (!template) {
         return null;
     }
     const element = document.createRange().createContextualFragment(template).firstChild;
-    if (element.nodeType === ELEMENT_NODE_TYPE) {
+    if (element && element.nodeType === ELEMENT_NODE_TYPE) {
         return element;
     }
     else {
@@ -70,6 +70,9 @@ function isFunction(value) {
     const type = typeof value;
     return !!value && type === 'function';
 }
+function isObject(val) {
+    return val && typeof val === 'object';
+}
 /**
  * Get file name from path
  * 1. "main.js" => "main.js"
@@ -133,6 +136,653 @@ function getScriptsAndStylesFullPaths(app, manifestResult) {
     };
 }
 
+const PLANET_SANDBOX_WINDOW_WHITELIST = window['___PLANET_SANDBOX_WINDOW_WHITELIST___'];
+const PLANET_SANDBOX_DOCUMENT_WHITELIST = window['___PLANET_SANDBOX_DOCUMENT_WHITELIST___'];
+const SANDBOX_INSTANCE = Symbol.for('PLANET_SANDBOX_INSTANCE');
+const RAW_NODE = Symbol.for('PLANET_RAW_NODE');
+const WINDOW_BIND_FN = Symbol.for('PLANET_WINDOW_BIND_FN');
+const DOCUMENT_BIND_FN = Symbol.for('PLANET_DOCUMENT_BIND_FN');
+
+const rawHasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwnProp(obj, key) {
+    return rawHasOwnProperty.call(obj, key);
+}
+function isValueDescriptor(desc) {
+    if (desc === undefined) {
+        return false;
+    }
+    return 'value' in desc || 'writable' in desc;
+}
+function isAccessorDescriptor(desc) {
+    if (desc === undefined) {
+        return false;
+    }
+    return 'get' in desc || 'set' in desc;
+}
+function isNonWriteableValue(desc) {
+    return desc && desc.configurable === false && 'value' in desc && desc.writable === false;
+}
+function isInvalidSetAccessor(desc) {
+    if (desc && desc.configurable === false && 'set' in desc && desc.set === undefined) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function isInvalidGetAccessor(desc) {
+    if (desc && desc.configurable === false && 'get' in desc && desc.get === undefined) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function transferParams(args) {
+    args = Array.isArray(args) ? args : Array.from(args);
+    return args.map(arg => {
+        return arg[RAW_NODE] ? arg[RAW_NODE] : arg;
+    });
+}
+const buildInProps = ['length', 'caller', 'callee', 'arguments', 'prototype', Symbol.hasInstance];
+function transferProps(o, n) {
+    for (const key of Reflect.ownKeys(o)) {
+        if (buildInProps.includes(key)) {
+            continue;
+        }
+        const desc = Object.getOwnPropertyDescriptor(n, key);
+        if (desc && desc.writable) {
+            n[key] = o[key];
+        }
+    }
+}
+function bind(fn, context) {
+    const fNOP = function () { };
+    function bound() {
+        const args = transferParams(arguments);
+        if (this instanceof bound) {
+            const obj = new fn(...args);
+            Object.setPrototypeOf(obj, bound.prototype);
+            return obj;
+        }
+        else {
+            return fn.apply(context, args);
+        }
+    }
+    bound.$native = fn;
+    transferProps(fn, bound);
+    if (fn.prototype) {
+        fNOP.prototype = fn.prototype;
+    }
+    bound.prototype = new fNOP();
+    if (Symbol.hasInstance) {
+        Object.defineProperty(bound, Symbol.hasInstance, {
+            configurable: true,
+            value(instance) {
+                const op = fn.prototype;
+                return isObject(op) || typeof op === 'function' ? instance instanceof fn : false;
+            }
+        });
+    }
+    return bound;
+}
+function createFakeObject(target, writableKeys) {
+    const fakeObject = {};
+    const propertyMap = {};
+    const storageBox = Object.create(null);
+    const propertyNames = Object.getOwnPropertyNames(target);
+    const def = (p) => {
+        const descriptor = Object.getOwnPropertyDescriptor(target, p);
+        if (descriptor === null || descriptor === void 0 ? void 0 : descriptor.configurable) {
+            const hasGetter = hasOwnProp(descriptor, 'get');
+            const hasSetter = hasOwnProp(descriptor, 'set');
+            const canWritable = writableKeys && writableKeys.length > 0 && writableKeys.includes(p);
+            if (hasGetter) {
+                descriptor.get = () => (hasOwnProp(storageBox, p) ? storageBox[p] : target[p]);
+            }
+            if (hasSetter) {
+                descriptor.set = val => {
+                    storageBox[p] = val;
+                    return true;
+                };
+            }
+            if (canWritable) {
+                if (descriptor.writable === false) {
+                    descriptor.writable = true;
+                }
+                else if (hasGetter) {
+                    descriptor.set = val => {
+                        storageBox[p] = val;
+                        return true;
+                    };
+                }
+            }
+            Object.defineProperty(fakeObject, p, Object.freeze(descriptor));
+        }
+    };
+    propertyNames.forEach(p => {
+        propertyMap[p] = true;
+        def(p);
+    });
+    // 再次循环是为了处理原型链中的属性
+    for (const prop in target) {
+        if (!propertyMap[prop]) {
+            def(prop);
+        }
+    }
+    return fakeObject;
+}
+
+const esGlobalFunctions = ('eval,isFinite,isNaN,parseFloat,parseInt,' +
+    // URL handling functions
+    'decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+    // Constructor properties of the global object
+    'Array,ArrayBuffer,BigInt,BigInt64Array,BigUint64Array,Boolean,DataView,Date,Error,EvalError,' +
+    'FinalizationRegistry,Float32Array,Float64Array,Function,Int8Array,Int16Array,Int32Array,Map,Number,' +
+    'Object,Promise,Proxy,RangeError,ReferenceError,RegExp,Set,SharedArrayBuffer,String,Symbol,SyntaxError,' +
+    'TypeError,Uint8Array,Uint8ClampedArray,Uint16Array,Uint32Array,URIError,WeakMap,WeakRef,WeakSet,' +
+    // Other Properties of the Global Object
+    'Atomics,JSON,Math,Reflect').split(',');
+const whitelistVariables = PLANET_SANDBOX_WINDOW_WHITELIST || [];
+function isConstructor(fn) {
+    const fp = fn.prototype;
+    const hasConstructor = fp && fp.constructor === fn && Object.getOwnPropertyNames(fp).length > 1;
+    const functionStr = !hasConstructor && fn.toString();
+    return hasConstructor || /^function\s+[A-Z]/.test(functionStr) || /^class\b/.test(functionStr);
+}
+const unscopables = {
+    undefined: true,
+    Array: true,
+    Object: true,
+    String: true,
+    Boolean: true,
+    Math: true,
+    Number: true,
+    Symbol: true,
+    parseFloat: true,
+    Float32Array: true
+};
+class ProxyWindow {
+    constructor(sandbox) {
+        this.sandbox = sandbox;
+        this.definedVariables = new Set();
+    }
+    createGetter() {
+        return (target, key, receiver) => {
+            if (key === Symbol.unscopables) {
+                return unscopables;
+            }
+            if (key === SANDBOX_INSTANCE) {
+                return this.sandbox;
+            }
+            let value = null;
+            if (whitelistVariables.includes(key)) {
+                return Reflect.get(window, key);
+            }
+            else {
+                value = hasOwnProp(target, key) ? Reflect.get(target, key, receiver) : Reflect.get(window, key);
+            }
+            if (isFunction(value)) {
+                if (esGlobalFunctions.includes(key) ||
+                    whitelistVariables.includes(key) ||
+                    this.sandbox.rewriteVariables.includes(key) ||
+                    this.definedVariables.has(key) ||
+                    isConstructor(value)) {
+                    return value;
+                }
+                else {
+                    const newValue = hasOwnProp(value, WINDOW_BIND_FN) ? value[WINDOW_BIND_FN] : bind(value, window);
+                    const desc = Object.getOwnPropertyDescriptor(target, key);
+                    if (isNonWriteableValue(desc)) {
+                        return value;
+                    }
+                    if (isInvalidGetAccessor(desc)) {
+                        return undefined;
+                    }
+                    value[WINDOW_BIND_FN] = newValue;
+                    return newValue;
+                }
+            }
+            else {
+                return value;
+            }
+        };
+    }
+    createSetter() {
+        return (target, key, value, receiver) => {
+            const desc = Object.getOwnPropertyDescriptor(whitelistVariables.includes(key) ? window : receiver ? receiver : target, key);
+            if (desc && isNonWriteableValue(desc)) {
+                if (!Object.is(value, desc.value)) {
+                    return false;
+                }
+                else {
+                    return true;
+                }
+            }
+            if (isInvalidSetAccessor(desc)) {
+                return false;
+            }
+            if (whitelistVariables.includes(key)) {
+                return Reflect.set(window, key, value);
+            }
+            else {
+                const success = Reflect.set(target, key, value, receiver);
+                if (success) {
+                    if (this.sandbox.running) {
+                        this.definedVariables.add(key);
+                    }
+                }
+                return success;
+            }
+        };
+    }
+    createDefineProperty() {
+        return (target, p, descriptor) => {
+            if (whitelistVariables.includes(p)) {
+                return Reflect.defineProperty(window, p, descriptor);
+            }
+            else {
+                const success = Reflect.defineProperty(target, p, descriptor);
+                if (this.sandbox.running && success) {
+                    this.definedVariables.add(p);
+                }
+                return success;
+            }
+        };
+    }
+    createDeleteProperty() {
+        return (target, p) => {
+            if (hasOwnProp(target, p)) {
+                delete target[p];
+                if (this.sandbox.running && this.definedVariables.has(p)) {
+                    this.definedVariables.delete(p);
+                }
+            }
+            return true;
+        };
+    }
+    createHas() {
+        return (_target, key) => {
+            return !whitelistVariables.includes(key);
+        };
+    }
+    create() {
+        const fakeWindow = createFakeObject(window, this.sandbox.rewriteVariables);
+        const baseHandlers = {
+            get: this.createGetter(),
+            set: this.createSetter(),
+            defineProperty: this.createDefineProperty(),
+            deleteProperty: this.createDeleteProperty()
+        };
+        const proxy = new Proxy(fakeWindow, Object.assign(Object.assign({}, baseHandlers), { has: this.createHas() }));
+        const subProxy = new Proxy(fakeWindow, baseHandlers);
+        proxy.self = subProxy;
+        proxy.window = subProxy;
+        proxy.globalThis = subProxy;
+        proxy.top = window.top === window ? subProxy : window.top;
+        proxy.parent = window.parent === window ? subProxy : window.top;
+        return proxy;
+    }
+}
+
+function eventListenerPatch(sandbox) {
+    const rawAddEventListener = window.addEventListener;
+    const rawRemoveEventListener = window.removeEventListener;
+    const listenerSubscriptions = new Map();
+    function addEventListener(type, listener, options) {
+        const observable = new Observable(() => {
+            rawAddEventListener.call(this, type, listener, options);
+            return () => {
+                rawRemoveEventListener.call(this, type, listener, options);
+            };
+        });
+        const subscription = observable.subscribe(() => { });
+        listenerSubscriptions.set(listener, subscription);
+    }
+    function removeEventListener(type, listener) {
+        const subscription = listenerSubscriptions.get(listener);
+        if (subscription) {
+            subscription.unsubscribe();
+            listenerSubscriptions.delete(listener);
+        }
+    }
+    return {
+        rewrite: {
+            addEventListener: addEventListener.bind(window),
+            removeEventListener: removeEventListener.bind(window)
+        },
+        init() {
+            const fakeDocument = sandbox.global.document;
+            if (fakeDocument) {
+                fakeDocument.addEventListener = addEventListener.bind(document);
+                fakeDocument.removeEventListener = removeEventListener.bind(document);
+            }
+        },
+        destroy() {
+            listenerSubscriptions.forEach(subscription => subscription.unsubscribe());
+            listenerSubscriptions.clear();
+        }
+    };
+}
+
+const rawDocument = Document;
+const whitelist = ['cookie', 'title', 'location', ...(PLANET_SANDBOX_DOCUMENT_WHITELIST || [])];
+class ProxyDocument {
+    constructor() { }
+    createGetter() {
+        return (target, p, receiver) => {
+            const value = hasOwnProp(target, p) ? Reflect.get(target, p, receiver) : Reflect.get(document, p);
+            if (p === 'activeElement') {
+                return Reflect.get(document, p);
+            }
+            // TODO: 处理动态节点
+            // if (p === 'createElement') {
+            //     return function(tagName: string, options: ElementCreationOptions) {
+            //         const created = value.call(document, tagName, options);
+            //         if (isObject(created)) {
+            //             created[SANDBOX_INSTANCE] = sandbox;
+            //         }
+            //         return created;
+            //     };
+            // }
+            if (isFunction(value)) {
+                let newValue = hasOwnProp(value, DOCUMENT_BIND_FN) ? value[DOCUMENT_BIND_FN] : null;
+                if (!newValue) {
+                    newValue = bind(value, document);
+                }
+                const desc = Object.getOwnPropertyDescriptor(target, p);
+                if (desc && isNonWriteableValue(desc)) {
+                    if (!Object.is(newValue, desc.value)) {
+                        return value;
+                    }
+                }
+                if (isInvalidGetAccessor(desc)) {
+                    return undefined;
+                }
+                value[DOCUMENT_BIND_FN] = newValue;
+                return newValue;
+            }
+            return value;
+        };
+    }
+    createSetter() {
+        return (target, p, value, receiver) => {
+            const desc = Object.getOwnPropertyDescriptor(whitelist.includes(p) ? document : receiver || target, p);
+            if (desc && isNonWriteableValue(desc)) {
+                if (Object.is(value, desc.value)) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+            if (isInvalidSetAccessor(desc)) {
+                return false;
+            }
+            return whitelist.includes(p) ? Reflect.set(document, p, value) : Reflect.set(target, p, value, receiver);
+        };
+    }
+    createDefineProperty() {
+        return (target, p, descriptor) => {
+            return whitelist.includes(p)
+                ? Reflect.defineProperty(document, p, descriptor)
+                : Reflect.defineProperty(target, p, descriptor);
+        };
+    }
+    create() {
+        let proxyDocument = null;
+        const fakeDocument = createFakeObject(document);
+        const getter = this.createGetter();
+        const fakeDocumentProto = new Proxy(fakeDocument, {
+            get: (...args) => {
+                return getter(...args);
+            }
+        });
+        const fakeDocumentCtor = function Document() {
+            if (!(this instanceof fakeDocumentCtor)) {
+                throw new TypeError(`Failed to construct 'Document': Please use the 'new' operator.`);
+            }
+            const docInstance = new rawDocument();
+            Object.setPrototypeOf(docInstance, fakeDocument);
+            return docInstance;
+        };
+        fakeDocumentCtor.prototype = fakeDocumentProto;
+        fakeDocumentCtor.prototype.constructor = fakeDocumentCtor;
+        if (Symbol.hasInstance) {
+            Object.defineProperty(fakeDocumentCtor, Symbol.hasInstance, {
+                configurable: true,
+                value(value) {
+                    let proto = value;
+                    if (proto === document) {
+                        return true;
+                    }
+                    while ((proto = Object.getPrototypeOf(proto))) {
+                        if (proto === fakeDocumentProto) {
+                            return true;
+                        }
+                    }
+                    const cloned = function () { };
+                    cloned.prototype = fakeDocument;
+                    return value instanceof cloned;
+                }
+            });
+        }
+        proxyDocument = new Proxy(Object.create(fakeDocumentProto, {
+            currentScript: {
+                value: null,
+                writable: true
+            },
+            [RAW_NODE]: {
+                writable: false,
+                configurable: false,
+                value: document
+            }
+        }), {
+            set: this.createSetter(),
+            defineProperty: this.createDefineProperty()
+        });
+        return {
+            document: proxyDocument,
+            Document: fakeDocumentCtor
+        };
+    }
+}
+
+function documentPatch() {
+    const proxyDocument = new ProxyDocument();
+    const { document, Document } = proxyDocument.create();
+    return {
+        rewrite: {
+            document,
+            Document
+        }
+    };
+}
+
+const rawSetTimeout = window.setTimeout;
+const rawClearTimeout = window.clearTimeout;
+const rawSetInterval = window.setInterval;
+const rawClearInterval = window.clearInterval;
+function timerPatch() {
+    const timeout = new Set();
+    const interval = new Set();
+    function rewriteSetTimeout(handler, ms, ...args) {
+        const timeoutId = rawSetTimeout(handler, ms, ...args);
+        timeout.add(timeoutId);
+        return timeoutId;
+    }
+    function rewriteClearTimeout(timeoutId) {
+        timeout.delete(timeoutId);
+        rawClearTimeout(timeoutId);
+    }
+    function rewriteSetInterval(handler, ms, ...args) {
+        const intervalId = rawSetInterval(handler, ms, ...args);
+        interval.add(intervalId);
+        return intervalId;
+    }
+    function rewriteClearInterval(intervalId) {
+        interval.delete(intervalId);
+        rawClearInterval(intervalId);
+    }
+    return {
+        rewrite: {
+            setTimeout: rewriteSetTimeout,
+            clearTimeout: rewriteClearTimeout,
+            setInterval: rewriteSetInterval,
+            clearInterval: rewriteClearInterval
+        },
+        destroy: () => {
+            timeout.forEach(timeoutId => {
+                rawClearTimeout(timeoutId);
+            });
+            interval.forEach(intervalId => {
+                rawClearInterval(intervalId);
+            });
+        }
+    };
+}
+
+const PLANET_STORAGE_PREFIX = '__planet-storage-';
+class RewriteStorage {
+    constructor(app, rawStorage) {
+        this.rawStorage = rawStorage;
+        this.prefix = `${PLANET_STORAGE_PREFIX}${app}__:`;
+    }
+    get length() {
+        return this.getKeys().length;
+    }
+    getKeys() {
+        return Object.keys(this.rawStorage).filter(key => key.startsWith(this.prefix));
+    }
+    key(n) {
+        const key = this.getKeys()[n];
+        return key ? key.substring(this.prefix.length) : null;
+    }
+    getItem(key) {
+        return this.rawStorage.getItem(`${this.prefix + key}`);
+    }
+    setItem(key, value) {
+        this.rawStorage.setItem(`${this.prefix + key}`, value);
+    }
+    removeItem(key) {
+        this.rawStorage.removeItem(`${this.prefix + key}`);
+    }
+    clear() {
+        this.getKeys().forEach(key => {
+            this.rawStorage.removeItem(key);
+        });
+    }
+}
+function storagePatch(sandbox) {
+    return {
+        rewrite: {
+            localStorage: new RewriteStorage(sandbox.app, localStorage),
+            sessionStorage: new RewriteStorage(sandbox.app, sessionStorage)
+        }
+    };
+}
+
+const sandboxPatches = [documentPatch, eventListenerPatch, timerPatch, storagePatch];
+function getSandboxPatchHandlers(sandbox) {
+    return sandboxPatches.map(patch => {
+        return patch(sandbox);
+    });
+}
+
+function execScript(code, url, global, strictGlobal) {
+    const sourceUrl = '//# sourceURL='.concat(url, '\n');
+    const window = (0, eval)('window');
+    window.tempGlobal = global;
+    code = strictGlobal
+        ? ';(function(window, self, globalThis){with(window){;'
+            .concat(code, '\n')
+            .concat(sourceUrl, '}}).bind(window.tempGlobal)(window.tempGlobal, window.tempGlobal, window.tempGlobal);')
+        : ';(function(window, self, globalThis){;'
+            .concat(code, '\n')
+            .concat(sourceUrl, '}).bind(window.tempGlobal)(window.tempGlobal, window.tempGlobal, window.tempGlobal);');
+    (0, eval)(code);
+    delete window.tempGlobal;
+}
+
+class Sandbox {
+    execScript(code, url = '') {
+        execScript(code, url, this.global, !!this.options.strictGlobal);
+    }
+}
+
+class ProxySandbox extends Sandbox {
+    constructor(app, options) {
+        super();
+        this.app = app;
+        this.options = options;
+        this.running = false;
+        this.patchHandlers = [];
+        this.patchHandlers = getSandboxPatchHandlers(this);
+        this.start();
+    }
+    start() {
+        this.running = true;
+        this.rewriteVariables = this.getPatchRewriteVariables();
+        const proxyWindow = new ProxyWindow(this);
+        this.global = proxyWindow.create();
+        this.execPatchHandlers();
+    }
+    destroy() {
+        this.running = false;
+        this.patchHandlers.forEach(handler => {
+            if (handler.destroy) {
+                handler.destroy();
+            }
+        });
+    }
+    getPatchRewriteVariables() {
+        return this.patchHandlers.reduce((pre, cur) => {
+            return [...pre, ...(cur.rewrite ? Object.keys(cur.rewrite) : [])];
+        }, []);
+    }
+    execPatchHandlers() {
+        this.patchHandlers.forEach(handler => {
+            if (handler.rewrite) {
+                for (const key in handler.rewrite) {
+                    if (handler.rewrite[key]) {
+                        this.global[key] = handler.rewrite[key];
+                    }
+                }
+            }
+            if (handler.init) {
+                handler === null || handler === void 0 ? void 0 : handler.init();
+            }
+        });
+    }
+}
+
+class SnapshotSandbox extends Sandbox {
+    constructor(app, options) {
+        super();
+        this.app = app;
+        this.options = options;
+        this.start();
+    }
+    start() { }
+    destroy() { }
+}
+
+const defaultOptions = {
+    strictGlobal: false
+};
+function createSandbox(app, options) {
+    options = Object.assign({}, defaultOptions, options || {});
+    if (window.Proxy) {
+        return new ProxySandbox(app, options);
+    }
+    else {
+        return new SnapshotSandbox(app, options);
+    }
+}
+function getSandboxInstance() {
+    return window[SANDBOX_INSTANCE];
+}
+
 class AssetsLoader {
     constructor(http) {
         this.http = http;
@@ -195,6 +845,40 @@ class AssetsLoader {
             document.body.appendChild(script);
         });
     }
+    loadScriptWithSandbox(app, src) {
+        const id = hashCode(src);
+        if (this.loadedSources.includes(id)) {
+            return of({
+                src: src,
+                hashCode: id,
+                loaded: true,
+                status: 'Loaded'
+            });
+        }
+        return new Observable((observer) => {
+            this.http.get(src, { responseType: 'text' }).subscribe((code) => {
+                this.loadedSources.push(id);
+                const sandbox = createSandbox(app);
+                sandbox.execScript(code, src);
+                observer.next({
+                    src: src,
+                    hashCode: id,
+                    loaded: true,
+                    status: 'Loaded'
+                });
+                observer.complete();
+            }, error => {
+                observer.error({
+                    src: src,
+                    hashCode: id,
+                    loaded: false,
+                    status: 'Error',
+                    error: error
+                });
+                observer.complete();
+            });
+        });
+    }
     loadStyle(src) {
         const id = hashCode(src);
         if (this.loadedSources.includes(id)) {
@@ -235,14 +919,23 @@ class AssetsLoader {
             head.appendChild(link);
         });
     }
-    loadScripts(sources, serial = false) {
+    loadScripts(sources, options = {
+        serial: false,
+        sandbox: false
+    }) {
         if (isEmpty(sources)) {
             return of(null);
         }
         const observables = sources.map(src => {
-            return this.loadScript(src);
+            // TODO: 暂时只支持Proxy沙箱
+            if (options.sandbox && window.Proxy) {
+                return this.loadScriptWithSandbox(options.app, src);
+            }
+            else {
+                return this.loadScript(src);
+            }
         });
-        if (serial) {
+        if (options.serial) {
             const a = concat(...observables).pipe(map(item => {
                 return of([item]);
             }), concatAll());
@@ -260,19 +953,27 @@ class AssetsLoader {
             return this.loadStyle(src);
         }));
     }
-    loadScriptsAndStyles(scripts = [], styles = [], serial = false) {
-        return forkJoin([this.loadScripts(scripts, serial), this.loadStyles(styles)]);
+    loadScriptsAndStyles(scripts = [], styles = [], options) {
+        return forkJoin([this.loadScripts(scripts, options), this.loadStyles(styles)]);
     }
     loadAppAssets(app) {
         if (app.manifest) {
             return this.loadManifest(`${app.manifest}?t=${new Date().getTime()}`).pipe(switchMap(manifestResult => {
                 const { scripts, styles } = getScriptsAndStylesFullPaths(app, manifestResult);
-                return this.loadScriptsAndStyles(scripts, styles, app.loadSerial);
+                return this.loadScriptsAndStyles(scripts, styles, {
+                    app: app.name,
+                    sandbox: app.sandbox,
+                    serial: app.loadSerial
+                });
             }));
         }
         else {
             const { scripts, styles } = getScriptsAndStylesFullPaths(app);
-            return this.loadScriptsAndStyles(scripts, styles, app.loadSerial);
+            return this.loadScriptsAndStyles(scripts, styles, {
+                app: app.name,
+                sandbox: app.sandbox,
+                serial: app.loadSerial
+            });
         }
     }
     loadManifest(url) {
@@ -296,15 +997,15 @@ class PlanetApplicationRef {
         this.name = name;
         if (options) {
             this.template = options.template;
-            this.innerSelector = this.template ? getTagNameByTemplate(this.template) : null;
+            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;
-        // };
+        NgZone.isInAngularZone = () => {
+            // @ts-ignore
+            return window.Zone.current._properties[`ngx-planet-${name}`] === true;
+        };
     }
     get selector() {
         return this.innerSelector;
@@ -312,17 +1013,22 @@ class PlanetApplicationRef {
     get bootstrapped() {
         return !!this.appModuleRef;
     }
+    get ngZone() {
+        var _a;
+        return (_a = this.appModuleRef) === null || _a === void 0 ? void 0 : _a.injector.get(NgZone);
+    }
+    get sandbox() {
+        return getSandboxInstance();
+    }
     // 子应用路由变化后同步修改 portal 的 Route
     syncPortalRouteWhenNavigationEnd() {
-        const router = this.appModuleRef.injector.get(Router);
-        const ngZone = this.appModuleRef.injector.get(NgZone);
+        var _a;
+        const router = (_a = this.appModuleRef) === null || _a === void 0 ? void 0 : _a.injector.get(Router);
         if (router) {
             router.events.subscribe(event => {
+                var _a;
                 if (event instanceof NavigationEnd) {
-                    ngZone.onStable
-                        .asObservable()
-                        .pipe(take(1))
-                        .subscribe(() => {
+                    (_a = this.ngZone) === null || _a === void 0 ? void 0 : _a.onStable.asObservable().pipe(take(1)).subscribe(() => {
                         this.portalApp.router.navigateByUrl(event.url);
                     });
                 }
@@ -342,16 +1048,18 @@ class PlanetApplicationRef {
         }));
     }
     getRouter() {
-        return this.appModuleRef.injector.get(Router);
+        var _a;
+        return (_a = this.appModuleRef) === null || _a === void 0 ? void 0 : _a.injector.get(Router);
     }
     getCurrentRouterStateUrl() {
-        return this.getRouter().routerState.snapshot.url;
+        var _a;
+        return (_a = this.getRouter()) === null || _a === void 0 ? void 0 : _a.routerState.snapshot.url;
     }
     navigateByUrl(url) {
-        const ngZone = this.appModuleRef.injector.get(NgZone);
+        var _a;
         const router = this.getRouter();
-        ngZone.run(() => {
-            router.navigateByUrl(url);
+        (_a = this.ngZone) === null || _a === void 0 ? void 0 : _a.run(() => {
+            router === null || router === void 0 ? void 0 : router.navigateByUrl(url);
         });
     }
     getComponentFactory() {
@@ -366,8 +1074,11 @@ class PlanetApplicationRef {
             if (router) {
                 router.dispose();
             }
+            if (this.sandbox) {
+                this.sandbox.destroy();
+            }
             this.appModuleRef.destroy();
-            delete this.appModuleRef;
+            this.appModuleRef = undefined;
         }
     }
 }
@@ -397,10 +1108,13 @@ function getPlanetApplicationRef(appName) {
     }
 }
 function setPortalApplicationData(data) {
-    globalPlanet.portalApplication.data = data;
+    if (globalPlanet.portalApplication) {
+        globalPlanet.portalApplication.data = data;
+    }
 }
 function getPortalApplicationData() {
-    return globalPlanet.portalApplication.data;
+    var _a;
+    return (_a = globalPlanet.portalApplication) === null || _a === void 0 ? void 0 : _a.data;
 }
 function setApplicationLoader(loader) {
     globalPlanet.applicationLoader = loader;
@@ -607,7 +1321,7 @@ function setDebugFactory(debug) {
     _debugFactory = debug;
 }
 function clearDebugFactory() {
-    setDebugFactory(undefined);
+    _debugFactory = undefined;
     _debuggerMap = {};
 }
 function getDebugFactory() {
@@ -760,7 +1474,7 @@ class PlanetApplicationLoader {
                             debug(`[routeChange] app(${app.name}) status is bootstrapped, show app and active`);
                             this.showApp(app);
                             const appRef = getPlanetApplicationRef(app.name);
-                            appRef.navigateByUrl(event.url);
+                            appRef === null || appRef === void 0 ? void 0 : appRef.navigateByUrl(event.url);
                             this.setAppStatus(app, ApplicationStatus.active);
                             this.setLoadingDone();
                             return of(app);
@@ -778,11 +1492,11 @@ class PlanetApplicationLoader {
                             debug(`[routeChange] app(${app.name}) is active, do nothings`);
                             const appRef = getPlanetApplicationRef(app.name);
                             // Backwards compatibility sub app use old version which has not getCurrentRouterStateUrl
-                            const currentUrl = appRef.getCurrentRouterStateUrl
+                            const currentUrl = (appRef === null || appRef === void 0 ? void 0 : appRef.getCurrentRouterStateUrl)
                                 ? appRef.getCurrentRouterStateUrl()
                                 : '';
                             if (currentUrl !== event.url) {
-                                appRef.navigateByUrl(event.url);
+                                appRef === null || appRef === void 0 ? void 0 : appRef.navigateByUrl(event.url);
                             }
                             return of(app);
                         }
@@ -853,14 +1567,14 @@ class PlanetApplicationLoader {
     }
     hideApp(planetApp) {
         const appRef = getPlanetApplicationRef(planetApp.name);
-        const appRootElement = document.querySelector(appRef.selector || planetApp.selector);
+        const appRootElement = document.querySelector((appRef === null || appRef === void 0 ? void 0 : appRef.selector) || planetApp.selector);
         if (appRootElement) {
             appRootElement.setAttribute('style', 'display:none;');
         }
     }
     showApp(planetApp) {
         const appRef = getPlanetApplicationRef(planetApp.name);
-        const appRootElement = document.querySelector(appRef.selector || planetApp.selector);
+        const appRootElement = document.querySelector((appRef === null || appRef === void 0 ? void 0 : appRef.selector) || planetApp.selector);
         if (appRootElement) {
             appRootElement.setAttribute('style', '');
         }
@@ -871,9 +1585,9 @@ class PlanetApplicationLoader {
             appRef.destroy();
         }
         const container = getHTMLElement(planetApp.hostParent);
-        const appRootElement = container.querySelector((appRef && appRef.selector) || planetApp.selector);
+        const appRootElement = container === null || container === void 0 ? void 0 : container.querySelector((appRef && appRef.selector) || planetApp.selector);
         if (appRootElement) {
-            container.removeChild(appRootElement);
+            container === null || container === void 0 ? void 0 : container.removeChild(appRootElement);
         }
     }
     bootstrapApp(app, defaultStatus = 'display') {
@@ -967,13 +1681,15 @@ class PlanetApplicationLoader {
     }
     preloadApps(activeApps) {
         setTimeout(() => {
-            const toPreloadApps = this.planetApplicationService.getAppsToPreload(activeApps ? activeApps.map(item => item.name) : null);
+            const toPreloadApps = this.planetApplicationService.getAppsToPreload(activeApps ? activeApps.map(item => item.name) : undefined);
             debug(`start preload apps: ${this.getAppNames(toPreloadApps)}`);
             const loadApps$ = toPreloadApps.map(preloadApp => {
                 return this.preloadInternal(preloadApp);
             });
             forkJoin(loadApps$).subscribe({
-                error: error => this.errorHandler(error)
+                error: error => {
+                    this.errorHandler(error);
+                }
             });
         });
     }
@@ -1008,6 +1724,9 @@ class PlanetApplicationLoader {
                         return this.bootstrapApp(app, 'hidden');
                     });
                 }
+            }), catchError(error => {
+                this.errorHandler(error);
+                return of(null);
             }), map(() => {
                 return getPlanetApplicationRef(app.name);
             }));
@@ -1104,7 +1823,7 @@ class Planet {
         this.subscription = this.router.events
             .pipe(filter(event => {
             return event instanceof NavigationEnd;
-        }), map((event) => {
+        }), map(event => {
             return event.urlAfterRedirects || event.url;
         }), startWith(location.pathname), distinctUntilChanged())
             .subscribe((url) => {
@@ -1114,7 +1833,8 @@ class Planet {
         });
     }
     stop() {
-        this.subscription.unsubscribe();
+        var _a;
+        (_a = this.subscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
     }
 }
 Planet.ɵprov = i0.ɵɵdefineInjectable({ factory: function Planet_Factory() { return new Planet(i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i3.Router), i0.ɵɵinject(PLANET_APPLICATIONS, 8)); }, token: Planet, providedIn: "root" });
@@ -1277,7 +1997,7 @@ class PlanetComponentLoader {
     load(app, componentName, config) {
         const result = this.getPlantAppRef(app).pipe(delayWhen(appRef => {
             if (appRef.getComponentFactory()) {
-                return of();
+                return of('');
             }
             else {
                 // Because register use 'setTimeout',so timer 20
@@ -1291,8 +2011,6 @@ class PlanetComponentLoader {
             else {
                 throw new Error(`${app}'s component(${componentName}) is not registered`);
             }
-        }), finalize(() => {
-            this.applicationRef.tick();
         }), shareReplay());
         result.subscribe();
         return result;