@zstackui/qiankun 2.6.3-beta-5

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

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.patchStrictSandbox = patchStrictSandbox;
+var _utils = require("../../../utils");
+var _common = require("../../common");
+var _common2 = require("./common");
+/**
+ * @author Kuitos
+ * @since 2020-10-13
+ */
+
+// Get native global window with a sandbox disgusted way, thus we could share it between qiankun instances🤪
+Object.defineProperty(_utils.nativeGlobal, '__proxyAttachContainerConfigMap__', {
+  enumerable: false,
+  writable: true
+});
+// Share proxyAttachContainerConfigMap between multiple qiankun instance, thus they could access the same record
+_utils.nativeGlobal.__proxyAttachContainerConfigMap__ = _utils.nativeGlobal.__proxyAttachContainerConfigMap__ || new WeakMap();
+var proxyAttachContainerConfigMap = _utils.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 ((0, _common2.isHijackingTag)(tagName)) {
+        var _ref = (0, _common.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;
+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 = (0, _common2.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();
+    }
+    (0, _common2.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() {
+      (0, _common2.rebuildCSSRules)(dynamicStyleSheetElements, function (stylesheetElement) {
+        var appWrapper = appWrapperGetter();
+        if (!appWrapper.contains(stylesheetElement)) {
+          _common2.rawHeadAppendChild.call(appWrapper, stylesheetElement);
+          return true;
+        }
+        return false;
+      });
+    };
+  };
+}

package/lib/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/lib/sandbox/patchers/dynamicAppend/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "patchLooseSandbox", {
+  enumerable: true,
+  get: function get() {
+    return _forLooseSandbox.patchLooseSandbox;
+  }
+});
+Object.defineProperty(exports, "patchStrictSandbox", {
+  enumerable: true,
+  get: function get() {
+    return _forStrictSandbox.patchStrictSandbox;
+  }
+});
+var _forLooseSandbox = require("./forLooseSandbox");
+var _forStrictSandbox = require("./forStrictSandbox");

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

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

package/lib/sandbox/patchers/historyListener.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = patch;
+var _isFunction2 = _interopRequireDefault(require("lodash/isFunction"));
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+
+function patch() {
+  // FIXME umi unmount feature request
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  var rawHistoryListen = function rawHistoryListen(_) {
+    return _noop2.default;
+  };
+  var historyListeners = [];
+  var historyUnListens = [];
+  if (window.g_history && (0, _isFunction2.default)(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 = _noop2.default;
+    /*
+     还存在余量 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 && (0, _isFunction2.default)(window.g_history.listen)) {
+      window.g_history.listen = rawHistoryListen;
+    }
+    return rebuild;
+  };
+}

package/lib/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/lib/sandbox/patchers/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.css = void 0;
+exports.patchAtBootstrapping = patchAtBootstrapping;
+exports.patchAtMounting = patchAtMounting;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _interfaces = require("../../interfaces");
+var css = _interopRequireWildcard(require("./css"));
+exports.css = css;
+var _dynamicAppend = require("./dynamicAppend");
+var _historyListener = _interopRequireDefault(require("./historyListener"));
+var _interval = _interopRequireDefault(require("./interval"));
+var _windowListener = _interopRequireDefault(require("./windowListener"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+
+function patchAtMounting(appName, elementGetter, sandbox, scopedCSS, excludeAssetFilter) {
+  var _a;
+  var basePatchers = [function () {
+    return (0, _interval.default)(sandbox.proxy);
+  }, function () {
+    return (0, _windowListener.default)(sandbox.proxy);
+  }, function () {
+    return (0, _historyListener.default)();
+  }];
+  var patchersInSandbox = (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _interfaces.SandBoxType.LegacyProxy, [].concat(basePatchers, [function () {
+    return (0, _dynamicAppend.patchLooseSandbox)(appName, elementGetter, sandbox.proxy, true, scopedCSS, excludeAssetFilter);
+  }])), _interfaces.SandBoxType.Proxy, [].concat(basePatchers, [function () {
+    return (0, _dynamicAppend.patchStrictSandbox)(appName, elementGetter, sandbox.proxy, true, scopedCSS, excludeAssetFilter);
+  }])), _interfaces.SandBoxType.Snapshot, [].concat(basePatchers, [function () {
+    return (0, _dynamicAppend.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();
+  });
+}
+function patchAtBootstrapping(appName, elementGetter, sandbox, scopedCSS, excludeAssetFilter) {
+  var _a;
+  var patchersInSandbox = (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, _interfaces.SandBoxType.LegacyProxy, [function () {
+    return (0, _dynamicAppend.patchLooseSandbox)(appName, elementGetter, sandbox.proxy, false, scopedCSS, excludeAssetFilter);
+  }]), _interfaces.SandBoxType.Proxy, [function () {
+    return (0, _dynamicAppend.patchStrictSandbox)(appName, elementGetter, sandbox.proxy, false, scopedCSS, excludeAssetFilter);
+  }]), _interfaces.SandBoxType.Snapshot, [function () {
+    return (0, _dynamicAppend.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();
+  });
+}

package/lib/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/lib/sandbox/patchers/interval.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = patch;
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+/* eslint-disable no-param-reassign */
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+
+var rawWindowInterval = window.setInterval;
+var rawWindowClearInterval = window.clearInterval;
+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((0, _toConsumableArray2.default)(intervals), [intervalId]);
+    return intervalId;
+  };
+  return function free() {
+    intervals.forEach(function (id) {
+      return global.clearInterval(id);
+    });
+    global.setInterval = rawWindowInterval;
+    global.clearInterval = rawWindowClearInterval;
+    return _noop2.default;
+  };
+}

package/lib/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/lib/sandbox/patchers/windowListener.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = patch;
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+/* eslint-disable no-param-reassign */
+/**
+ * @author Kuitos
+ * @since 2019-04-11
+ */
+
+var rawAddEventListener = window.addEventListener;
+var rawRemoveEventListener = window.removeEventListener;
+function patch(global) {
+  var listenerMap = new Map();
+  global.addEventListener = function (type, listener, options) {
+    var listeners = listenerMap.get(type) || [];
+    listenerMap.set(type, [].concat((0, _toConsumableArray2.default)(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 (0, _toConsumableArray2.default)(listeners).forEach(function (listener) {
+        return global.removeEventListener(type, listener);
+      });
+    });
+    global.addEventListener = rawAddEventListener;
+    global.removeEventListener = rawRemoveEventListener;
+    return _noop2.default;
+  };
+}

package/lib/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);
+}