@zstackui/qiankun 2.6.3-beta-5

package/es/sandbox/patchers/dynamicAppend/forStrictSandbox.js

@@ -0,0 +1,103 @@
+/**
+ * @author Kuitos
+ * @since 2020-10-13
+ */
+import { nativeGlobal } from '../../../utils';
+import { getCurrentRunningApp } from '../../common';
+import { isHijackingTag, patchHTMLDynamicAppendPrototypeFunctions, rawHeadAppendChild, rebuildCSSRules, recordStyledComponentsCSSRules } from './common';
+// Get native global window with a sandbox disgusted way, thus we could share it between qiankun instances🤪
+Object.defineProperty(nativeGlobal, '__proxyAttachContainerConfigMap__', {
+  enumerable: false,
+  writable: true
+});
+// Share proxyAttachContainerConfigMap between multiple qiankun instance, thus they could access the same record
+nativeGlobal.__proxyAttachContainerConfigMap__ = nativeGlobal.__proxyAttachContainerConfigMap__ || new WeakMap();
+var proxyAttachContainerConfigMap = nativeGlobal.__proxyAttachContainerConfigMap__;
+var elementAttachContainerConfigMap = new WeakMap();
+var docCreatePatchedMap = new WeakMap();
+function patchDocumentCreateElement() {
+  var docCreateElementFnBeforeOverwrite = docCreatePatchedMap.get(document.createElement);
+  if (!docCreateElementFnBeforeOverwrite) {
+    var rawDocumentCreateElement = document.createElement;
+    Document.prototype.createElement = function createElement(tagName, options) {
+      var element = rawDocumentCreateElement.call(this, tagName, options);
+      if (isHijackingTag(tagName)) {
+        var _ref = getCurrentRunningApp() || {},
+          currentRunningSandboxProxy = _ref.window;
+        if (currentRunningSandboxProxy) {
+          var proxyContainerConfig = proxyAttachContainerConfigMap.get(currentRunningSandboxProxy);
+          if (proxyContainerConfig) {
+            elementAttachContainerConfigMap.set(element, proxyContainerConfig);
+          }
+        }
+      }
+      return element;
+    };
+    // It means it have been overwritten while createElement is an own property of document
+    if (document.hasOwnProperty('createElement')) {
+      document.createElement = Document.prototype.createElement;
+    }
+    docCreatePatchedMap.set(Document.prototype.createElement, rawDocumentCreateElement);
+  }
+  return function unpatch() {
+    if (docCreateElementFnBeforeOverwrite) {
+      Document.prototype.createElement = docCreateElementFnBeforeOverwrite;
+      document.createElement = docCreateElementFnBeforeOverwrite;
+    }
+  };
+}
+var bootstrappingPatchCount = 0;
+var mountingPatchCount = 0;
+export function patchStrictSandbox(appName, appWrapperGetter, proxy) {
+  var mounting = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  var scopedCSS = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var excludeAssetFilter = arguments.length > 5 ? arguments[5] : undefined;
+  var containerConfig = proxyAttachContainerConfigMap.get(proxy);
+  if (!containerConfig) {
+    containerConfig = {
+      appName: appName,
+      proxy: proxy,
+      appWrapperGetter: appWrapperGetter,
+      dynamicStyleSheetElements: [],
+      strictGlobal: true,
+      excludeAssetFilter: excludeAssetFilter,
+      scopedCSS: scopedCSS
+    };
+    proxyAttachContainerConfigMap.set(proxy, containerConfig);
+  }
+  // all dynamic style sheets are stored in proxy container
+  var _containerConfig = containerConfig,
+    dynamicStyleSheetElements = _containerConfig.dynamicStyleSheetElements;
+  var unpatchDocumentCreate = patchDocumentCreateElement();
+  var unpatchDynamicAppendPrototypeFunctions = patchHTMLDynamicAppendPrototypeFunctions(function (element) {
+    return elementAttachContainerConfigMap.has(element);
+  }, function (element) {
+    return elementAttachContainerConfigMap.get(element);
+  });
+  if (!mounting) bootstrappingPatchCount++;
+  if (mounting) mountingPatchCount++;
+  return function free() {
+    // bootstrap patch just called once but its freer will be called multiple times
+    if (!mounting && bootstrappingPatchCount !== 0) bootstrappingPatchCount--;
+    if (mounting) mountingPatchCount--;
+    var allMicroAppUnmounted = mountingPatchCount === 0 && bootstrappingPatchCount === 0;
+    // release the overwrite prototype after all the micro apps unmounted
+    if (allMicroAppUnmounted) {
+      unpatchDynamicAppendPrototypeFunctions();
+      unpatchDocumentCreate();
+    }
+    recordStyledComponentsCSSRules(dynamicStyleSheetElements);
+    // As now the sub app content all wrapped with a special id container,
+    // the dynamic style sheet would be removed automatically while unmoutting
+    return function rebuild() {
+      rebuildCSSRules(dynamicStyleSheetElements, function (stylesheetElement) {
+        var appWrapper = appWrapperGetter();
+        if (!appWrapper.contains(stylesheetElement)) {
+          rawHeadAppendChild.call(appWrapper, stylesheetElement);
+          return true;
+        }
+        return false;
+      });
+    };
+  };
+}

package/es/sandbox/patchers/dynamicAppend/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author Kuitos
+ * @since 2020-10-13
+ */
+export { patchLooseSandbox } from './forLooseSandbox';
+export { patchStrictSandbox } from './forStrictSandbox';

package/es/sandbox/patchers/dynamicAppend/index.js

@@ -0,0 +1,6 @@
+/**
+ * @author Kuitos
+ * @since 2020-10-13
+ */
+export { patchLooseSandbox } from './forLooseSandbox';
+export { patchStrictSandbox } from './forStrictSandbox';

package/es/sandbox/patchers/historyListener.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+export default function patch(): () => (...args: any[]) => void;

package/es/sandbox/patchers/historyListener.js

@@ -0,0 +1,54 @@
+import _isFunction from "lodash/isFunction";
+import _noop from "lodash/noop";
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+export default function patch() {
+  // FIXME umi unmount feature request
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  var rawHistoryListen = function rawHistoryListen(_) {
+    return _noop;
+  };
+  var historyListeners = [];
+  var historyUnListens = [];
+  if (window.g_history && _isFunction(window.g_history.listen)) {
+    rawHistoryListen = window.g_history.listen.bind(window.g_history);
+    window.g_history.listen = function (listener) {
+      historyListeners.push(listener);
+      var unListen = rawHistoryListen(listener);
+      historyUnListens.push(unListen);
+      return function () {
+        unListen();
+        historyUnListens.splice(historyUnListens.indexOf(unListen), 1);
+        historyListeners.splice(historyListeners.indexOf(listener), 1);
+      };
+    };
+  }
+  return function free() {
+    var rebuild = _noop;
+    /*
+     还存在余量 listener 表明未被卸载，存在两种情况
+     1. 应用在 unmout 时未正确卸载 listener
+     2. listener 是应用 mount 之前绑定的，
+     第二种情况下应用在下次 mount 之前需重新绑定该 listener
+     */
+    if (historyListeners.length) {
+      rebuild = function rebuild() {
+        // 必须使用 window.g_history.listen 的方式重新绑定 listener，从而能保证 rebuild 这部分也能被捕获到，否则在应用卸载后无法正确的移除这部分副作用
+        historyListeners.forEach(function (listener) {
+          return window.g_history.listen(listener);
+        });
+      };
+    }
+    // 卸载余下的 listener
+    historyUnListens.forEach(function (unListen) {
+      return unListen();
+    });
+    // restore
+    if (window.g_history && _isFunction(window.g_history.listen)) {
+      window.g_history.listen = rawHistoryListen;
+    }
+    return rebuild;
+  };
+}

package/es/sandbox/patchers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+import type { Freer, SandBox } from '../../interfaces';
+import * as css from './css';
+export declare function patchAtMounting(appName: string, elementGetter: () => HTMLElement | ShadowRoot, sandbox: SandBox, scopedCSS: boolean, excludeAssetFilter?: CallableFunction): Freer[];
+export declare function patchAtBootstrapping(appName: string, elementGetter: () => HTMLElement | ShadowRoot, sandbox: SandBox, scopedCSS: boolean, excludeAssetFilter?: CallableFunction): Freer[];
+export { css };

package/es/sandbox/patchers/index.js

@@ -0,0 +1,45 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+import { SandBoxType } from '../../interfaces';
+import * as css from './css';
+import { patchLooseSandbox, patchStrictSandbox } from './dynamicAppend';
+import patchHistoryListener from './historyListener';
+import patchInterval from './interval';
+import patchWindowListener from './windowListener';
+export function patchAtMounting(appName, elementGetter, sandbox, scopedCSS, excludeAssetFilter) {
+  var _a;
+  var basePatchers = [function () {
+    return patchInterval(sandbox.proxy);
+  }, function () {
+    return patchWindowListener(sandbox.proxy);
+  }, function () {
+    return patchHistoryListener();
+  }];
+  var patchersInSandbox = _defineProperty(_defineProperty(_defineProperty({}, SandBoxType.LegacyProxy, [].concat(basePatchers, [function () {
+    return patchLooseSandbox(appName, elementGetter, sandbox.proxy, true, scopedCSS, excludeAssetFilter);
+  }])), SandBoxType.Proxy, [].concat(basePatchers, [function () {
+    return patchStrictSandbox(appName, elementGetter, sandbox.proxy, true, scopedCSS, excludeAssetFilter);
+  }])), SandBoxType.Snapshot, [].concat(basePatchers, [function () {
+    return patchLooseSandbox(appName, elementGetter, sandbox.proxy, true, scopedCSS, excludeAssetFilter);
+  }]));
+  return (_a = patchersInSandbox[sandbox.type]) === null || _a === void 0 ? void 0 : _a.map(function (patch) {
+    return patch();
+  });
+}
+export function patchAtBootstrapping(appName, elementGetter, sandbox, scopedCSS, excludeAssetFilter) {
+  var _a;
+  var patchersInSandbox = _defineProperty(_defineProperty(_defineProperty({}, SandBoxType.LegacyProxy, [function () {
+    return patchLooseSandbox(appName, elementGetter, sandbox.proxy, false, scopedCSS, excludeAssetFilter);
+  }]), SandBoxType.Proxy, [function () {
+    return patchStrictSandbox(appName, elementGetter, sandbox.proxy, false, scopedCSS, excludeAssetFilter);
+  }]), SandBoxType.Snapshot, [function () {
+    return patchLooseSandbox(appName, elementGetter, sandbox.proxy, false, scopedCSS, excludeAssetFilter);
+  }]);
+  return (_a = patchersInSandbox[sandbox.type]) === null || _a === void 0 ? void 0 : _a.map(function (patch) {
+    return patch();
+  });
+}
+export { css };

package/es/sandbox/patchers/interval.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+export default function patch(global: Window): () => (...args: any[]) => void;

package/es/sandbox/patchers/interval.js

@@ -0,0 +1,34 @@
+import _noop from "lodash/noop";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+/* eslint-disable no-param-reassign */
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+var rawWindowInterval = window.setInterval;
+var rawWindowClearInterval = window.clearInterval;
+export default function patch(global) {
+  var intervals = [];
+  global.clearInterval = function (intervalId) {
+    intervals = intervals.filter(function (id) {
+      return id !== intervalId;
+    });
+    return rawWindowClearInterval.call(window, intervalId);
+  };
+  global.setInterval = function (handler, timeout) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    var intervalId = rawWindowInterval.apply(void 0, [handler, timeout].concat(args));
+    intervals = [].concat(_toConsumableArray(intervals), [intervalId]);
+    return intervalId;
+  };
+  return function free() {
+    intervals.forEach(function (id) {
+      return global.clearInterval(id);
+    });
+    global.setInterval = rawWindowInterval;
+    global.clearInterval = rawWindowClearInterval;
+    return _noop;
+  };
+}

package/es/sandbox/patchers/windowListener.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+export default function patch(global: WindowProxy): () => (...args: any[]) => void;

package/es/sandbox/patchers/windowListener.js

@@ -0,0 +1,34 @@
+import _noop from "lodash/noop";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+/* eslint-disable no-param-reassign */
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+var rawAddEventListener = window.addEventListener;
+var rawRemoveEventListener = window.removeEventListener;
+export default function patch(global) {
+  var listenerMap = new Map();
+  global.addEventListener = function (type, listener, options) {
+    var listeners = listenerMap.get(type) || [];
+    listenerMap.set(type, [].concat(_toConsumableArray(listeners), [listener]));
+    return rawAddEventListener.call(window, type, listener, options);
+  };
+  global.removeEventListener = function (type, listener, options) {
+    var storedTypeListeners = listenerMap.get(type);
+    if (storedTypeListeners && storedTypeListeners.length && storedTypeListeners.indexOf(listener) !== -1) {
+      storedTypeListeners.splice(storedTypeListeners.indexOf(listener), 1);
+    }
+    return rawRemoveEventListener.call(window, type, listener, options);
+  };
+  return function free() {
+    listenerMap.forEach(function (listeners, type) {
+      return _toConsumableArray(listeners).forEach(function (listener) {
+        return global.removeEventListener(type, listener);
+      });
+    });
+    global.addEventListener = rawAddEventListener;
+    global.removeEventListener = rawRemoveEventListener;
+    return _noop;
+  };
+}

package/es/sandbox/proxySandbox.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @author Kuitos
+ * @since 2020-3-31
+ */
+import type { SandBox } from '../interfaces';
+import { SandBoxType } from '../interfaces';
+/**
+ * 基于 Proxy 实现的沙箱
+ */
+export default class ProxySandbox implements SandBox {
+    /** window 值变更记录 */
+    private updatedValueSet;
+    name: string;
+    type: SandBoxType;
+    proxy: WindowProxy;
+    globalContext: typeof window;
+    sandboxRunning: boolean;
+    latestSetProp: PropertyKey | null;
+    private registerRunningApp;
+    active(): void;
+    inactive(): void;
+    constructor(name: string, globalContext?: Window & typeof globalThis, transformStorage?: boolean);
+}

package/es/sandbox/proxySandbox.js

@@ -0,0 +1,315 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { SandBoxType } from '../interfaces';
+import { nativeGlobal, nextTask } from '../utils';
+import { getTargetValue, setCurrentRunningApp, getCurrentRunningApp, getZsLocalStorage, getZsSessionStorage } from './common';
+/**
+ * fastest(at most time) unique array method
+ * @see https://jsperf.com/array-filter-unique/30
+ */
+function uniq(array) {
+  return array.filter(function filter(element) {
+    return element in this ? false : this[element] = true;
+  }, Object.create(null));
+}
+// zone.js will overwrite Object.defineProperty
+var rawObjectDefineProperty = Object.defineProperty;
+var variableWhiteListInDev = process.env.NODE_ENV === 'development' || window.__QIANKUN_DEVELOPMENT__ ? [
+// for react hot reload
+// see https://github.com/facebook/create-react-app/blob/66bf7dfc43350249e2f09d138a20840dae8a0a4a/packages/react-error-overlay/src/index.js#L180
+'__REACT_ERROR_OVERLAY_GLOBAL_HOOK__'] : [];
+// who could escape the sandbox
+var variableWhiteList = [
+// FIXME System.js used a indirect call with eval, which would make it scope escape to global
+// To make System.js works well, we write it back to global window temporary
+// see https://github.com/systemjs/systemjs/blob/457f5b7e8af6bd120a279540477552a07d5de086/src/evaluate.js#L106
+'System',
+// see https://github.com/systemjs/systemjs/blob/457f5b7e8af6bd120a279540477552a07d5de086/src/instantiate.js#L357
+'__cjsWrapper'].concat(variableWhiteListInDev);
+/*
+ variables who are impossible to be overwrite need to be escaped from proxy sandbox for performance reasons
+ */
+var unscopables = {
+  undefined: true,
+  Array: true,
+  Object: true,
+  String: true,
+  Boolean: true,
+  Math: true,
+  Number: true,
+  Symbol: true,
+  parseFloat: true,
+  Float32Array: true,
+  isNaN: true,
+  Infinity: true,
+  Reflect: true,
+  Float64Array: true,
+  Function: true,
+  Map: true,
+  NaN: true,
+  Promise: true,
+  Proxy: true,
+  Set: true,
+  parseInt: true,
+  requestAnimationFrame: true
+};
+var useNativeWindowForBindingsProps = new Map([['fetch', true], ['mockDomAPIInBlackList', process.env.NODE_ENV === 'test']]);
+function createFakeWindow(globalContext) {
+  // map always has the fastest performance in has check scenario
+  // see https://jsperf.com/array-indexof-vs-set-has/23
+  var propertiesWithGetter = new Map();
+  var fakeWindow = {};
+  /*
+   copy the non-configurable property of global to fakeWindow
+   see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor
+   > A property cannot be reported as non-configurable, if it does not exists as an own property of the target object or if it exists as a configurable own property of the target object.
+   */
+  Object.getOwnPropertyNames(globalContext).filter(function (p) {
+    var descriptor = Object.getOwnPropertyDescriptor(globalContext, p);
+    return !(descriptor === null || descriptor === void 0 ? void 0 : descriptor.configurable);
+  }).forEach(function (p) {
+    var descriptor = Object.getOwnPropertyDescriptor(globalContext, p);
+    if (descriptor) {
+      var hasGetter = Object.prototype.hasOwnProperty.call(descriptor, 'get');
+      /*
+       make top/self/window property configurable and writable, otherwise it will cause TypeError while get trap return.
+       see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get
+       > The value reported for a property must be the same as the value of the corresponding target object property if the target object property is a non-writable, non-configurable data property.
+       */
+      if (p === 'top' || p === 'parent' || p === 'self' || p === 'window' || process.env.NODE_ENV === 'test' && (p === 'mockTop' || p === 'mockSafariTop')) {
+        descriptor.configurable = true;
+        /*
+         The descriptor of window.window/window.top/window.self in Safari/FF are accessor descriptors, we need to avoid adding a data descriptor while it was
+         Example:
+          Safari/FF: Object.getOwnPropertyDescriptor(window, 'top') -> {get: function, set: undefined, enumerable: true, configurable: false}
+          Chrome: Object.getOwnPropertyDescriptor(window, 'top') -> {value: Window, writable: false, enumerable: true, configurable: false}
+         */
+        if (!hasGetter) {
+          descriptor.writable = true;
+        }
+      }
+      if (hasGetter) propertiesWithGetter.set(p, true);
+      // freeze the descriptor to avoid being modified by zone.js
+      // see https://github.com/angular/zone.js/blob/a5fe09b0fac27ac5df1fa746042f96f05ccb6a00/lib/browser/define-property.ts#L71
+      rawObjectDefineProperty(fakeWindow, p, Object.freeze(descriptor));
+    }
+  });
+  return {
+    fakeWindow: fakeWindow,
+    propertiesWithGetter: propertiesWithGetter
+  };
+}
+var activeSandboxCount = 0;
+/**
+ * 基于 Proxy 实现的沙箱
+ */
+var ProxySandbox = /*#__PURE__*/function () {
+  function ProxySandbox(name) {
+    var _this = this;
+    var globalContext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window;
+    var transformStorage = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    _classCallCheck(this, ProxySandbox);
+    /** window 值变更记录 */
+    this.updatedValueSet = new Set();
+    this.sandboxRunning = true;
+    this.latestSetProp = null;
+    this.name = name;
+    this.globalContext = globalContext;
+    this.type = SandBoxType.Proxy;
+    var updatedValueSet = this.updatedValueSet;
+    var _createFakeWindow = createFakeWindow(globalContext),
+      fakeWindow = _createFakeWindow.fakeWindow,
+      propertiesWithGetter = _createFakeWindow.propertiesWithGetter;
+    var descriptorTargetMap = new Map();
+    var hasOwnProperty = function hasOwnProperty(key) {
+      return fakeWindow.hasOwnProperty(key) || globalContext.hasOwnProperty(key);
+    };
+    var proxy = new Proxy(fakeWindow, {
+      set: function set(target, p, value) {
+        if (_this.sandboxRunning) {
+          _this.registerRunningApp(name, proxy);
+          // We must kept its description while the property existed in globalContext before
+          if (!target.hasOwnProperty(p) && globalContext.hasOwnProperty(p)) {
+            var descriptor = Object.getOwnPropertyDescriptor(globalContext, p);
+            var writable = descriptor.writable,
+              configurable = descriptor.configurable,
+              enumerable = descriptor.enumerable;
+            if (writable) {
+              Object.defineProperty(target, p, {
+                configurable: configurable,
+                enumerable: enumerable,
+                writable: writable,
+                value: value
+              });
+            }
+          } else {
+            // @ts-ignore
+            target[p] = value;
+          }
+          if (variableWhiteList.indexOf(p) !== -1) {
+            // @ts-ignore
+            globalContext[p] = value;
+          }
+          updatedValueSet.add(p);
+          _this.latestSetProp = p;
+          return true;
+        }
+        if (process.env.NODE_ENV === 'development') {
+          console.warn("[qiankun] Set window.".concat(p.toString(), " while sandbox destroyed or inactive in ").concat(name, "!"));
+        }
+        // 在 strict-mode 下，Proxy 的 handler.set 返回 false 会抛出 TypeError，在沙箱卸载的情况下应该忽略错误
+        return true;
+      },
+      get: function get(target, p) {
+        _this.registerRunningApp(name, proxy);
+        if (p === Symbol.unscopables) return unscopables;
+        // avoid who using window.window or window.self to escape the sandbox environment to touch the really window
+        // see https://github.com/eligrey/FileSaver.js/blob/master/src/FileSaver.js#L13
+        if (p === 'window' || p === 'self') {
+          return proxy;
+        }
+        // hijack globalWindow accessing with globalThis keyword
+        if (p === 'globalThis') {
+          return proxy;
+        }
+        if (p === 'top' || p === 'parent' || process.env.NODE_ENV === 'test' && (p === 'mockTop' || p === 'mockSafariTop')) {
+          // if your master app in an iframe context, allow these props escape the sandbox
+          if (globalContext === globalContext.parent) {
+            return proxy;
+          }
+          return globalContext[p];
+        }
+        // proxy.hasOwnProperty would invoke getter firstly, then its value represented as globalContext.hasOwnProperty
+        if (p === 'hasOwnProperty') {
+          return hasOwnProperty;
+        }
+        if (p === 'document') {
+          return document;
+        }
+        if (p === 'eval') {
+          return eval;
+        }
+        if (transformStorage && p === 'localStorage') {
+          return getZsLocalStorage(name);
+        }
+        if (transformStorage && p === 'sessionStorage') {
+          return getZsSessionStorage(name);
+        }
+        var value = propertiesWithGetter.has(p) ? globalContext[p] : p in target ? target[p] : globalContext[p];
+        /* Some dom api must be bound to native window, otherwise it would cause exception like 'TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation'
+           See this code:
+             const proxy = new Proxy(window, {});
+             const proxyFetch = fetch.bind(proxy);
+             proxyFetch('https://qiankun.com');
+        */
+        var boundTarget = useNativeWindowForBindingsProps.get(p) ? nativeGlobal : globalContext;
+        return getTargetValue(boundTarget, value);
+      },
+      // trap in operator
+      // see https://github.com/styled-components/styled-components/blob/master/packages/styled-components/src/constants.js#L12
+      has: function has(target, p) {
+        return p in unscopables || p in target || p in globalContext;
+      },
+      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, p) {
+        /*
+         as the descriptor of top/self/window/mockTop in raw window are configurable but not in proxy target, we need to get it from target to avoid TypeError
+         see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor
+         > A property cannot be reported as non-configurable, if it does not exists as an own property of the target object or if it exists as a configurable own property of the target object.
+         */
+        if (target.hasOwnProperty(p)) {
+          var descriptor = Object.getOwnPropertyDescriptor(target, p);
+          descriptorTargetMap.set(p, 'target');
+          return descriptor;
+        }
+        if (globalContext.hasOwnProperty(p)) {
+          var _descriptor = Object.getOwnPropertyDescriptor(globalContext, p);
+          descriptorTargetMap.set(p, 'globalContext');
+          // A property cannot be reported as non-configurable, if it does not exists as an own property of the target object
+          if (_descriptor && !_descriptor.configurable) {
+            _descriptor.configurable = true;
+          }
+          return _descriptor;
+        }
+        return undefined;
+      },
+      // trap to support iterator with sandbox
+      ownKeys: function ownKeys(target) {
+        return uniq(Reflect.ownKeys(globalContext).concat(Reflect.ownKeys(target)));
+      },
+      defineProperty: function defineProperty(target, p, attributes) {
+        var from = descriptorTargetMap.get(p);
+        /*
+         Descriptor must be defined to native window while it comes from native window via Object.getOwnPropertyDescriptor(window, p),
+         otherwise it would cause a TypeError with illegal invocation.
+         */
+        switch (from) {
+          case 'globalContext':
+            return Reflect.defineProperty(globalContext, p, attributes);
+          default:
+            return Reflect.defineProperty(target, p, attributes);
+        }
+      },
+      deleteProperty: function deleteProperty(target, p) {
+        _this.registerRunningApp(name, proxy);
+        if (target.hasOwnProperty(p)) {
+          // @ts-ignore
+          delete target[p];
+          updatedValueSet.delete(p);
+          return true;
+        }
+        return true;
+      },
+      // makes sure `window instanceof Window` returns truthy in micro app
+      getPrototypeOf: function getPrototypeOf() {
+        return Reflect.getPrototypeOf(globalContext);
+      }
+    });
+    this.proxy = proxy;
+    activeSandboxCount++;
+  }
+  return _createClass(ProxySandbox, [{
+    key: "registerRunningApp",
+    value: function registerRunningApp(name, proxy) {
+      if (this.sandboxRunning) {
+        var currentRunningApp = getCurrentRunningApp();
+        if (!currentRunningApp || currentRunningApp.name !== name) {
+          setCurrentRunningApp({
+            name: name,
+            window: proxy
+          });
+        }
+        // FIXME if you have any other good ideas
+        // remove the mark in next tick, thus we can identify whether it in micro app or not
+        // this approach is just a workaround, it could not cover all complex cases, such as the micro app runs in the same task context with master in some case
+        nextTask(function () {
+          setCurrentRunningApp(null);
+        });
+      }
+    }
+  }, {
+    key: "active",
+    value: function active() {
+      if (!this.sandboxRunning) activeSandboxCount++;
+      this.sandboxRunning = true;
+    }
+  }, {
+    key: "inactive",
+    value: function inactive() {
+      var _this2 = this;
+      if (process.env.NODE_ENV === 'development') {
+        console.info("[qiankun:sandbox] ".concat(this.name, " modified global properties restore..."), _toConsumableArray(this.updatedValueSet.keys()));
+      }
+      if (--activeSandboxCount === 0) {
+        variableWhiteList.forEach(function (p) {
+          if (_this2.proxy.hasOwnProperty(p)) {
+            // @ts-ignore
+            delete _this2.globalContext[p];
+          }
+        });
+      }
+      this.sandboxRunning = false;
+    }
+  }]);
+}();
+export { ProxySandbox as default };