@worktile/planet 12.1.0 → 12.1.1

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

@@ -0,0 +1,24 @@
+import { SandboxOptions } from './sandbox';
+import { ProxySandbox } from './proxy/proxy-sandbox';
+import { SnapshotSandbox } from './snapshot/snapshot-sandbox';
+import { SANDBOX_INSTANCE } from './constants';
+
+export { Sandbox } from './sandbox';
+
+const defaultOptions: Partial<SandboxOptions> = {
+    strictGlobal: false
+};
+
+export function createSandbox(app: string, options?: SandboxOptions) {
+    options = Object.assign({}, defaultOptions, options || {});
+
+    if (window.Proxy) {
+        return new ProxySandbox(app, options);
+    } else {
+        return new SnapshotSandbox(app, options);
+    }
+}
+
+export function getSandboxInstance() {
+    return window[SANDBOX_INSTANCE];
+}

package/packages/planet/src/sandbox/proxy/patches/document.ts

@@ -0,0 +1,13 @@
+import { ProxyDocument } from '../proxies/document';
+import { SandboxPatchHandler } from '../types';
+
+export function documentPatch(): SandboxPatchHandler {
+    const proxyDocument = new ProxyDocument();
+    const { document, Document } = proxyDocument.create();
+    return {
+        rewrite: {
+            document,
+            Document
+        }
+    };
+}

package/packages/planet/src/sandbox/proxy/patches/eventListener.ts

@@ -0,0 +1,49 @@
+import { SandboxPatchHandler, ProxySandboxInstance } from '../types';
+import { Observable, Subscription } from 'rxjs';
+
+export function eventListenerPatch(sandbox: ProxySandboxInstance): SandboxPatchHandler {
+    const rawAddEventListener = window.addEventListener;
+    const rawRemoveEventListener = window.removeEventListener;
+    const listenerSubscriptions = new Map<EventListenerOrEventListenerObject, Subscription>();
+
+    function addEventListener(
+        type: string,
+        listener: EventListenerOrEventListenerObject,
+        options?: boolean | AddEventListenerOptions
+    ) {
+        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: string, listener: EventListenerOrEventListenerObject) {
+        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();
+        }
+    };
+}

package/packages/planet/src/sandbox/proxy/patches/index.ts

@@ -0,0 +1,13 @@
+import { ProxySandboxInstance, SandboxPatch, SandboxPatchHandler } from '../types';
+import { eventListenerPatch } from './eventListener';
+import { documentPatch } from './document';
+import { timerPatch } from './timer';
+import { storagePatch } from './storage';
+
+const sandboxPatches: SandboxPatch[] = [documentPatch, eventListenerPatch, timerPatch, storagePatch];
+
+export function getSandboxPatchHandlers(sandbox: ProxySandboxInstance): SandboxPatchHandler[] {
+    return sandboxPatches.map(patch => {
+        return patch(sandbox);
+    });
+}

package/packages/planet/src/sandbox/proxy/patches/storage.ts

@@ -0,0 +1,53 @@
+import { ProxySandboxInstance, SandboxPatchHandler } from '../types';
+
+const PLANET_STORAGE_PREFIX = '__planet-storage-';
+
+export class RewriteStorage {
+    prefix: string;
+    rawStorage: Storage;
+
+    constructor(app: string, rawStorage: Storage) {
+        this.rawStorage = rawStorage;
+        this.prefix = `${PLANET_STORAGE_PREFIX}${app}__:`;
+    }
+
+    get length() {
+        return this.getKeys().length;
+    }
+
+    private getKeys() {
+        return Object.keys(this.rawStorage).filter(key => key.startsWith(this.prefix));
+    }
+
+    key(n: number) {
+        const key = this.getKeys()[n];
+        return key ? key.substring(this.prefix.length) : null;
+    }
+
+    getItem(key: string) {
+        return this.rawStorage.getItem(`${this.prefix + key}`);
+    }
+
+    setItem(key: string, value: string) {
+        this.rawStorage.setItem(`${this.prefix + key}`, value);
+    }
+
+    removeItem(key: string) {
+        this.rawStorage.removeItem(`${this.prefix + key}`);
+    }
+
+    clear() {
+        this.getKeys().forEach(key => {
+            this.rawStorage.removeItem(key);
+        });
+    }
+}
+
+export function storagePatch(sandbox: ProxySandboxInstance): SandboxPatchHandler {
+    return {
+        rewrite: {
+            localStorage: new RewriteStorage(sandbox.app, localStorage),
+            sessionStorage: new RewriteStorage(sandbox.app, sessionStorage)
+        }
+    };
+}

package/packages/planet/src/sandbox/proxy/patches/timer.ts

@@ -0,0 +1,50 @@
+import { SandboxPatchHandler } from '../types';
+
+const rawSetTimeout = window.setTimeout;
+const rawClearTimeout = window.clearTimeout;
+const rawSetInterval = window.setInterval;
+const rawClearInterval = window.clearInterval;
+
+export function timerPatch(): SandboxPatchHandler {
+    const timeout = new Set<number>();
+    const interval = new Set<number>();
+
+    function rewriteSetTimeout(handler: TimerHandler, ms?: number, ...args: any[]) {
+        const timeoutId = rawSetTimeout(handler, ms, ...args);
+        timeout.add(timeoutId);
+        return timeoutId;
+    }
+
+    function rewriteClearTimeout(timeoutId: number) {
+        timeout.delete(timeoutId);
+        rawClearTimeout(timeoutId);
+    }
+
+    function rewriteSetInterval(handler: TimerHandler, ms: number, ...args: any[]) {
+        const intervalId = rawSetInterval(handler, ms, ...args);
+        interval.add(intervalId);
+        return intervalId;
+    }
+
+    function rewriteClearInterval(intervalId: number) {
+        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);
+            });
+        }
+    };
+}

package/packages/planet/src/sandbox/proxy/proxies/common.ts

@@ -0,0 +1,137 @@
+import { isObject } from '../../../helpers';
+import { RAW_NODE } from '../../constants';
+
+const rawHasOwnProperty = Object.prototype.hasOwnProperty;
+export function hasOwnProp(obj: any, key: PropertyKey): boolean {
+    return rawHasOwnProperty.call(obj, key);
+}
+
+export function isValueDescriptor(desc?: PropertyDescriptor) {
+    if (desc === undefined) {
+        return false;
+    }
+    return 'value' in desc || 'writable' in desc;
+}
+
+export function isAccessorDescriptor(desc?: PropertyDescriptor) {
+    if (desc === undefined) {
+        return false;
+    }
+    return 'get' in desc || 'set' in desc;
+}
+
+export function isNonWriteableValue(desc?: PropertyDescriptor) {
+    return desc && desc.configurable === false && 'value' in desc && desc.writable === false;
+}
+
+export function isInvalidSetAccessor(desc?: PropertyDescriptor) {
+    if (desc && desc.configurable === false && 'set' in desc && desc.set === undefined) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+export function isInvalidGetAccessor(desc?: PropertyDescriptor) {
+    if (desc && desc.configurable === false && 'get' in desc && desc.get === undefined) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+function transferParams(args: IArguments | Array<any>) {
+    args = Array.isArray(args) ? args : Array.from(args);
+    return args.map(arg => {
+        return arg[RAW_NODE] ? arg[RAW_NODE] : arg;
+    });
+}
+
+const buildInProps: PropertyKey[] = ['length', 'caller', 'callee', 'arguments', 'prototype', Symbol.hasInstance];
+function transferProps(o: Function, n: Function) {
+    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];
+        }
+    }
+}
+
+export function bind(fn: any, context: any) {
+    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: any) {
+                const op = fn.prototype;
+                return isObject(op) || typeof op === 'function' ? instance instanceof fn : false;
+            }
+        });
+    }
+    return bound;
+}
+
+export function createFakeObject(target: Record<PropertyKey, any>, writableKeys?: PropertyKey[]) {
+    const fakeObject = {};
+    const propertyMap: Record<string, string | boolean> = {};
+    const storageBox = Object.create(null);
+    const propertyNames = Object.getOwnPropertyNames(target);
+    const def = (p: string) => {
+        const descriptor = Object.getOwnPropertyDescriptor(target, p);
+        if (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 as any;
+}

package/packages/planet/src/sandbox/proxy/proxies/document.ts

@@ -0,0 +1,140 @@
+import { isFunction } from '../../../helpers';
+import { DOCUMENT_BIND_FN, PLANET_SANDBOX_DOCUMENT_WHITELIST, RAW_NODE } from '../../constants';
+import {
+    hasOwnProp,
+    createFakeObject,
+    isInvalidSetAccessor,
+    isNonWriteableValue,
+    bind,
+    isInvalidGetAccessor
+} from './common';
+
+const rawDocument = Document;
+const whitelist: PropertyKey[] = ['cookie', 'title', 'location', ...(PLANET_SANDBOX_DOCUMENT_WHITELIST || [])];
+
+export class ProxyDocument {
+    constructor() {}
+
+    private createGetter() {
+        return (target: any, p: PropertyKey, receiver?: any) => {
+            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;
+        };
+    }
+
+    private createSetter() {
+        return (target: any, p: PropertyKey, value: any, receiver: any) => {
+            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);
+        };
+    }
+
+    private createDefineProperty() {
+        return (target: any, p: PropertyKey, descriptor: PropertyDescriptor) => {
+            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: any) {
+                    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
+        };
+    }
+}

package/packages/planet/src/sandbox/proxy/proxies/window.ts

@@ -0,0 +1,176 @@
+import {
+    hasOwnProp,
+    createFakeObject,
+    bind,
+    isInvalidSetAccessor,
+    isNonWriteableValue,
+    isInvalidGetAccessor
+} from './common';
+import { PLANET_SANDBOX_WINDOW_WHITELIST, SANDBOX_INSTANCE, WINDOW_BIND_FN } from '../../constants';
+import { isFunction } from '../../../helpers';
+import { ProxySandboxInstance } from '../types';
+
+const esGlobalFunctions: PropertyKey[] = (
+    '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: () => void | FunctionConstructor) {
+    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 as string) || /^class\b/.test(functionStr as string);
+}
+
+const unscopables = {
+    undefined: true,
+    Array: true,
+    Object: true,
+    String: true,
+    Boolean: true,
+    Math: true,
+    Number: true,
+    Symbol: true,
+    parseFloat: true,
+    Float32Array: true
+};
+
+export class ProxyWindow {
+    constructor(private sandbox: ProxySandboxInstance) {}
+
+    private definedVariables = new Set();
+
+    private createGetter() {
+        return (target: Window, key: PropertyKey, receiver: any) => {
+            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;
+            }
+        };
+    }
+
+    private createSetter() {
+        return (target: Window, key: PropertyKey, value: unknown, receiver: any) => {
+            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;
+            }
+        };
+    }
+
+    private createDefineProperty() {
+        return (target: Window, p: PropertyKey, descriptor: PropertyDescriptor) => {
+            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;
+            }
+        };
+    }
+
+    private createDeleteProperty() {
+        return (target: Window, p: PropertyKey) => {
+            if (hasOwnProp(target, p)) {
+                delete (target as any)[p];
+                if (this.sandbox.running && this.definedVariables.has(p)) {
+                    this.definedVariables.delete(p);
+                }
+            }
+            return true;
+        };
+    }
+
+    private createHas() {
+        return (_target: Window, key: PropertyKey) => {
+            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, {
+            ...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;
+    }
+}