@worktile/planet 12.1.1 → 12.1.2

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

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

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

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

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

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

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

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

@@ -1,59 +0,0 @@
-import { ProxyWindow } from './proxies/window';
-import { getSandboxPatchHandlers } from './patches';
-import { SandboxPatchHandler } from './types';
-import { Global } from '../types';
-import { Sandbox, SandboxOptions } from '../sandbox';
-
-export class ProxySandbox extends Sandbox {
-    public running = false;
-
-    public global!: Global;
-
-    public rewriteVariables!: PropertyKey[];
-
-    private patchHandlers: SandboxPatchHandler[] = [];
-
-    constructor(public app: string, public options: SandboxOptions) {
-        super();
-        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();
-            }
-        });
-    }
-
-    private getPatchRewriteVariables() {
-        return this.patchHandlers.reduce<string[]>((pre, cur) => {
-            return [...pre, ...(cur.rewrite ? Object.keys(cur.rewrite) : [])];
-        }, []);
-    }
-
-    private 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?.init();
-            }
-        });
-    }
-}

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

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

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

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

package/packages/planet/src/test.ts

@@ -1,16 +0,0 @@
-// 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);