@module-federation/devtools 2.3.3 → 2.5.0

package/dist/es/utils/chrome/fast-refresh.js

@@ -1,30 +1,6 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -46,173 +22,321 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-var _a;
-import { loadScript } from "@module-federation/sdk";
-import { isObject, getUnpkgUrl } from "../index";
+import { getUnpkgUrl } from "../index";
 import { definePropertyGlobalVal } from "../sdk";
 import {
   __FEDERATION_DEVTOOLS__,
   __EAGER_SHARE__,
   __ENABLE_FAST_REFRESH__
 } from "../../template/constant";
-const SUPPORT_PKGS = ["react", "react-dom"];
-const fetchAndExecuteUmdSync = (url) => {
-  try {
-    const response = new XMLHttpRequest();
-    response.open("GET", url, false);
-    response.overrideMimeType("text/plain");
-    response.send();
-    if (response.status === 200) {
-      const scriptContent = response.responseText;
-      const moduleFunction = new Function(scriptContent);
-      return moduleFunction(window);
-    } else {
-      throw new Error(
-        `Failed to load module from ${url}: HTTP ${response.status}`
+var require_fast_refresh = __commonJS({
+  "src/utils/chrome/fast-refresh.ts"(exports) {
+    var _a;
+    const SUPPORT_PKGS = ["react", "react-dom"];
+    const DEFAULT_SHARE_SCOPE = "default";
+    const DEFAULT_GLOBAL_KEY_MAP = {
+      react: "React",
+      "react-dom": "ReactDOM"
+    };
+    const sanitizeWindowKey = (value) => value.replace(/[^a-zA-Z0-9_$]/g, "_");
+    const getShareScopes = (scope) => Array.isArray(scope) && scope.length ? scope : [DEFAULT_SHARE_SCOPE];
+    const getDefaultGlobalKey = (pkgName) => DEFAULT_GLOBAL_KEY_MAP[pkgName];
+    const getScopedGlobalKey = (scope, pkgName) => `${sanitizeWindowKey(scope)}_${sanitizeWindowKey(pkgName)}`;
+    const getWindowValue = (key) => window[key];
+    const setWindowValue = (key, value) => {
+      window[key] = value;
+    };
+    const setScopeGlobals = (pkgName, scopes, source) => {
+      if (!source) {
+        return source;
+      }
+      scopes.forEach((scope) => {
+        setWindowValue(getScopedGlobalKey(scope, pkgName), source);
+      });
+      return source;
+    };
+    const getScopeGlobal = (pkgName, scopes) => {
+      for (const scope of scopes) {
+        const scopeGlobal = getWindowValue(getScopedGlobalKey(scope, pkgName));
+        if (scopeGlobal) {
+          return scopeGlobal;
+        }
+      }
+      return void 0;
+    };
+    const getEagerShareInfo = (eagerShare) => {
+      if (!Array.isArray(eagerShare) || eagerShare.length < 2) {
+        return null;
+      }
+      const [, version, scopes] = eagerShare;
+      if (typeof version !== "string") {
+        return null;
+      }
+      return {
+        version,
+        scopes: getShareScopes(scopes)
+      };
+    };
+    const updateEagerShareInfo = (devtoolsMessage2, pkgName, version, scopes) => {
+      const existing = getEagerShareInfo(devtoolsMessage2[__EAGER_SHARE__]);
+      const mergedScopes = Array.from(
+        /* @__PURE__ */ new Set([...(existing == null ? void 0 : existing.scopes) || [], ...scopes])
       );
-    }
-  } catch (error) {
-    throw new Error(`Failed to fetch module from ${url}: ${error.message}`);
-  }
-};
-const getDevtoolsMessage = () => {
-  const devtoolsMessageStr = localStorage.getItem(__FEDERATION_DEVTOOLS__);
-  if (devtoolsMessageStr) {
-    try {
-      return JSON.parse(devtoolsMessageStr);
-    } catch (e) {
-      console.debug("Fast Refresh Plugin Error: ", e);
-    }
-  }
-  return null;
-};
-const devtoolsMessage = getDevtoolsMessage();
-if ((devtoolsMessage == null ? void 0 : devtoolsMessage[__ENABLE_FAST_REFRESH__]) && (devtoolsMessage == null ? void 0 : devtoolsMessage[__EAGER_SHARE__])) {
-  const [_name, version] = devtoolsMessage[__EAGER_SHARE__];
-  fetchAndExecuteUmdSync(getUnpkgUrl("react", version));
-  fetchAndExecuteUmdSync(getUnpkgUrl("react-dom", version));
-}
-const fastRefreshPlugin = () => {
-  return {
-    name: "mf-fast-refresh-plugin",
-    beforeInit(_a2) {
-      var _b = _a2, { userOptions } = _b, args = __objRest(_b, ["userOptions"]);
-      const shareInfo = userOptions.shared;
-      const twinsShareInfo = args.shareInfo;
-      let enableFastRefresh = false;
-      let devtoolsMessage2 = {};
+      devtoolsMessage2[__EAGER_SHARE__] = [pkgName, version, mergedScopes];
+      return {
+        shouldReload: !existing || existing.version !== version
+      };
+    };
+    const requestUmdSourceSync = (url) => {
+      try {
+        const response = new XMLHttpRequest();
+        response.open("GET", url, false);
+        response.overrideMimeType("text/plain");
+        response.send();
+        if (response.status === 200) {
+          return response.responseText;
+        }
+        throw new Error(
+          `Failed to load module from ${url}: HTTP ${response.status}`
+        );
+      } catch (error) {
+        throw new Error(`Failed to fetch module from ${url}: ${error.message}`);
+      }
+    };
+    const requestUmdSource = (url) => new Promise((resolve, reject) => {
+      try {
+        const response = new XMLHttpRequest();
+        response.open("GET", url, true);
+        response.overrideMimeType("text/plain");
+        response.onload = () => {
+          if (response.status === 200) {
+            resolve(response.responseText);
+            return;
+          }
+          reject(
+            new Error(
+              `Failed to load module from ${url}: HTTP ${response.status}`
+            )
+          );
+        };
+        response.onerror = () => {
+          reject(new Error(`Failed to fetch module from ${url}`));
+        };
+        response.send();
+      } catch (error) {
+        reject(new Error(`Failed to fetch module from ${url}: ${error.message}`));
+      }
+    });
+    const createUmdSandbox = (pkgName, scopes) => {
+      const sandboxTarget = /* @__PURE__ */ Object.create(null);
+      const sandbox = new Proxy(sandboxTarget, {
+        get(target, key) {
+          if (typeof key === "symbol") {
+            return Reflect.get(target, key);
+          }
+          if (key in target) {
+            return target[key];
+          }
+          const value = window[key];
+          return typeof value === "function" ? value.bind(window) : value;
+        },
+        set(target, key, value) {
+          target[key] = value;
+          return true;
+        },
+        has(target, key) {
+          return key in target || key in window;
+        }
+      });
+      sandboxTarget.window = sandbox;
+      sandboxTarget.self = sandbox;
+      sandboxTarget.globalThis = sandbox;
+      sandboxTarget.global = sandbox;
+      sandboxTarget.document = window.document;
+      if (pkgName === "react-dom") {
+        sandboxTarget.React = getScopeGlobal("react", scopes);
+      }
+      return sandbox;
+    };
+    const executeUmdModule = (scriptContent, pkgName, scopes) => {
+      const sandbox = createUmdSandbox(pkgName, scopes);
+      const moduleFunction = new Function(
+        "window",
+        "self",
+        "globalThis",
+        "global",
+        "document",
+        "exports",
+        "module",
+        "define",
+        "require",
+        scriptContent
+      );
+      moduleFunction.call(
+        sandbox,
+        sandbox,
+        sandbox,
+        sandbox,
+        sandbox,
+        sandbox.document,
+        void 0,
+        void 0,
+        void 0,
+        void 0
+      );
+      return sandbox[getDefaultGlobalKey(pkgName)];
+    };
+    const loadUmdModuleSync = (pkgName, version, scopes) => executeUmdModule(
+      requestUmdSourceSync(getUnpkgUrl(pkgName, version)),
+      pkgName,
+      scopes
+    );
+    const loadUmdModule = (pkgName, version, scopes) => __async(exports, null, function* () {
+      return executeUmdModule(
+        yield requestUmdSource(getUnpkgUrl(pkgName, version)),
+        pkgName,
+        scopes
+      );
+    });
+    const getDevtoolsMessage = () => {
       const devtoolsMessageStr = localStorage.getItem(__FEDERATION_DEVTOOLS__);
       if (devtoolsMessageStr) {
         try {
-          devtoolsMessage2 = JSON.parse(devtoolsMessageStr);
-          enableFastRefresh = devtoolsMessage2 == null ? void 0 : devtoolsMessage2[__ENABLE_FAST_REFRESH__];
+          return JSON.parse(devtoolsMessageStr);
         } catch (e) {
           console.debug("Fast Refresh Plugin Error: ", e);
         }
       }
-      if (!enableFastRefresh) {
-        return __spreadValues({
-          userOptions
-        }, args);
-      }
-      if (shareInfo && isObject(shareInfo)) {
-        let orderResolve;
-        const orderPromise = new Promise((resolve) => {
-          orderResolve = resolve;
-        });
-        Object.keys(shareInfo).forEach((share) => __async(this, null, function* () {
-          const sharedArr = Array.isArray(shareInfo[share]) ? shareInfo[share] : [shareInfo[share]];
-          let twinsSharedArr;
-          if (twinsShareInfo) {
-            twinsSharedArr = Array.isArray(twinsShareInfo[share]) ? twinsShareInfo[share] : [twinsShareInfo[share]];
+      return null;
+    };
+    const devtoolsMessage = getDevtoolsMessage();
+    const eagerShareInfo = getEagerShareInfo(devtoolsMessage == null ? void 0 : devtoolsMessage[__EAGER_SHARE__]);
+    if ((devtoolsMessage == null ? void 0 : devtoolsMessage[__ENABLE_FAST_REFRESH__]) && eagerShareInfo) {
+      const { version, scopes } = eagerShareInfo;
+      setScopeGlobals("react", scopes, loadUmdModuleSync("react", version, scopes));
+      setScopeGlobals(
+        "react-dom",
+        scopes,
+        loadUmdModuleSync("react-dom", version, scopes)
+      );
+    }
+    const fastRefreshPlugin = () => {
+      let orderResolve;
+      const orderPromise = new Promise((resolve) => {
+        orderResolve = resolve;
+      });
+      return {
+        name: "mf-fast-refresh-plugin",
+        beforeRegisterShare(args) {
+          var _a2;
+          const { pkgName, shared } = args;
+          if (!SUPPORT_PKGS.includes(pkgName)) {
+            return args;
           }
-          sharedArr.forEach((shared, idx) => {
-            var _a3;
-            if (!SUPPORT_PKGS.includes(share)) {
-              return;
+          const supportPkgName = pkgName;
+          const shareScopes = getShareScopes(shared.scope);
+          let enableFastRefresh = false;
+          let devtoolsMessage2 = {};
+          const devtoolsMessageStr = localStorage.getItem(__FEDERATION_DEVTOOLS__);
+          if (devtoolsMessageStr) {
+            try {
+              devtoolsMessage2 = JSON.parse(devtoolsMessageStr);
+              enableFastRefresh = devtoolsMessage2 == null ? void 0 : devtoolsMessage2[__ENABLE_FAST_REFRESH__];
+            } catch (e) {
+              console.debug("Fast Refresh Plugin Error: ", e);
             }
-            if ((_a3 = shared.shareConfig) == null ? void 0 : _a3.eager) {
-              if (!(devtoolsMessage2 == null ? void 0 : devtoolsMessage2[__EAGER_SHARE__])) {
-                const eagerShare = [];
-                eagerShare.push(share, shared.version);
-                devtoolsMessage2[__EAGER_SHARE__] = eagerShare;
-                localStorage.setItem(
-                  __FEDERATION_DEVTOOLS__,
-                  JSON.stringify(devtoolsMessage2)
-                );
+          }
+          if (!enableFastRefresh) {
+            return args;
+          }
+          if (((_a2 = shared.shareConfig) == null ? void 0 : _a2.eager) || shared.lib) {
+            if (!(devtoolsMessage2 == null ? void 0 : devtoolsMessage2[__EAGER_SHARE__])) {
+              const eagerShareInfo2 = updateEagerShareInfo(
+                devtoolsMessage2,
+                pkgName,
+                shared.version,
+                shareScopes
+              );
+              localStorage.setItem(
+                __FEDERATION_DEVTOOLS__,
+                JSON.stringify(devtoolsMessage2)
+              );
+              if (eagerShareInfo2.shouldReload) {
                 window.location.reload();
               }
-              if (share === "react-dom") {
-                shared.lib = () => window.ReactDOM;
-              }
-              if (share === "react") {
-                shared.lib = () => window.React;
-              }
-              return;
+            } else {
+              updateEagerShareInfo(
+                devtoolsMessage2,
+                pkgName,
+                shared.version,
+                shareScopes
+              );
+              localStorage.setItem(
+                __FEDERATION_DEVTOOLS__,
+                JSON.stringify(devtoolsMessage2)
+              );
+            }
+            if (pkgName === "react-dom") {
+              shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
             }
-            let get;
-            if (share === "react") {
-              get = () => loadScript(getUnpkgUrl(share, shared.version), {
-                attrs: {
-                  defer: false,
-                  async: false,
-                  "data-mf-injected": "true"
+            if (pkgName === "react") {
+              shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+            }
+            return args;
+          }
+          let get;
+          if (pkgName === "react") {
+            get = () => loadUmdModule(supportPkgName, shared.version, shareScopes).then((moduleValue) => {
+              setScopeGlobals(supportPkgName, shareScopes, moduleValue);
+              return moduleValue;
+            }).then(() => {
+              orderResolve();
+            });
+          }
+          if (pkgName === "react-dom") {
+            get = () => orderPromise.then(
+              () => loadUmdModule(supportPkgName, shared.version, shareScopes)
+            ).then((result) => {
+              setScopeGlobals(supportPkgName, shareScopes, result);
+              return result;
+            });
+          }
+          if (typeof get === "function") {
+            const finalGet = get;
+            if (pkgName === "react") {
+              shared.get = () => __async(this, null, function* () {
+                if (!getScopeGlobal(supportPkgName, shareScopes)) {
+                  yield finalGet();
+                  console.warn(
+                    "[Module Federation HMR]: You are using Module Federation Devtools to debug online host, it will cause your project load Dev mode React and ReactDOM. If not in this mode, please disable it in Module Federation Devtools"
+                  );
                 }
-              }).then(() => {
-                orderResolve();
+                shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+                return () => getScopeGlobal(supportPkgName, shareScopes);
               });
             }
-            if (share === "react-dom") {
-              get = () => orderPromise.then(
-                () => loadScript(getUnpkgUrl(share, shared.version), {
-                  attrs: { defer: true, async: false }
-                })
-              );
-            }
-            if (typeof get === "function") {
-              if (share === "react") {
-                shared.get = () => __async(this, null, function* () {
-                  if (!window.React) {
-                    yield get();
-                    console.warn(
-                      "[Module Federation HMR]: You are using Module Federation Devtools to debug online host, it will cause your project load Dev mode React and ReactDOM. If not in this mode, please disable it in Module Federation Devtools"
-                    );
-                  }
-                  shared.lib = () => window.React;
-                  return () => window.React;
-                });
-              }
-              if (share === "react-dom") {
-                shared.get = () => __async(this, null, function* () {
-                  if (!window.ReactDOM) {
-                    yield get();
-                  }
-                  shared.lib = () => window.ReactDOM;
-                  return () => window.ReactDOM;
-                });
-              }
-              if (twinsShareInfo) {
-                twinsSharedArr[idx].get = shared.get;
-              }
+            if (pkgName === "react-dom") {
+              shared.get = () => __async(this, null, function* () {
+                if (!getScopeGlobal(supportPkgName, shareScopes)) {
+                  yield finalGet();
+                }
+                shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+                return () => getScopeGlobal(supportPkgName, shareScopes);
+              });
             }
-          });
-        }));
-        return __spreadValues({
-          userOptions
-        }, args);
-      } else {
-        return __spreadValues({
-          userOptions
-        }, args);
-      }
+          }
+          return args;
+        }
+      };
+    };
+    if (!(window == null ? void 0 : window.__FEDERATION__)) {
+      definePropertyGlobalVal(window, "__FEDERATION__", {});
+      definePropertyGlobalVal(window, "__VMOK__", window.__FEDERATION__);
     }
-  };
-};
-if (!(window == null ? void 0 : window.__FEDERATION__)) {
-  definePropertyGlobalVal(window, "__FEDERATION__", {});
-  definePropertyGlobalVal(window, "__VMOK__", window.__FEDERATION__);
-}
-if (!(window == null ? void 0 : window.__FEDERATION__.__GLOBAL_PLUGIN__)) {
-  window.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
-}
-(_a = window.__FEDERATION__.__GLOBAL_PLUGIN__) == null ? void 0 : _a.push(fastRefreshPlugin());
+    if (!(window == null ? void 0 : window.__FEDERATION__.__GLOBAL_PLUGIN__)) {
+      window.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
+    }
+    (_a = window.__FEDERATION__.__GLOBAL_PLUGIN__) == null ? void 0 : _a.push(fastRefreshPlugin());
+  }
+});
+export default require_fast_refresh();

package/dist/es/utils/chrome/index.js

@@ -70,10 +70,11 @@ const syncActiveTab = (tabId) => __async(void 0, null, function* () {
       setTargetTab(tab);
       return tab;
     }
-    const [activeTab] = yield getTabs({
+    const tabs = yield getTabs({
       active: true,
       lastFocusedWindow: true
     });
+    const activeTab = Array.isArray(tabs) ? tabs[0] : void 0;
     setTargetTab(activeTab);
     return activeTab;
   } catch (error) {
@@ -96,9 +97,7 @@ function getInspectWindowTabId() {
         function(info, error) {
           const { tabId } = chrome.devtools.inspectedWindow;
           getTabs().then((tabs) => {
-            const target = tabs.find(
-              (tab) => tab.id === tabId
-            );
+            const target = Array.isArray(tabs) ? tabs.find((tab) => tab.id === tabId) : void 0;
             setTargetTab(target);
           });
           console.log(

package/dist/es/utils/chrome/messages.js

@@ -1,6 +1,12 @@
 const MESSAGE_OPEN_SIDE_PANEL = "mf-devtools/open-side-panel";
 const MESSAGE_ACTIVE_TAB_CHANGED = "mf-devtools/active-tab-changed";
+const MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT = "mf-devtools/observability-event";
+const OBSERVABILITY_DEVTOOLS_SOURCE = "module-federation/observability";
+const OBSERVABILITY_DEVTOOLS_STORAGE_KEY = "__MF_DEVTOOLS_OBSERVABILITY_CONFIG__";
 export {
   MESSAGE_ACTIVE_TAB_CHANGED,
-  MESSAGE_OPEN_SIDE_PANEL
+  MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT,
+  MESSAGE_OPEN_SIDE_PANEL,
+  OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY
 };

package/dist/es/utils/chrome/observability-plugin.js

@@ -0,0 +1,93 @@
+import {
+  ChromeObservabilityPlugin
+} from "@module-federation/observability-plugin/chrome-devtool";
+import {
+  OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+} from "./messages";
+import {
+  createObservabilityPluginOptions,
+  normalizeObservabilityDevtoolsConfig
+} from "./observability-shared";
+const DEVTOOLS_PLUGIN_NAME = "observability-plugin:chrome-extension";
+const LEGACY_DEVTOOLS_PLUGIN_NAME = "observability-plugin-devtools";
+const getFederationWindow = () => window;
+const safeReadStoredConfig = () => {
+  var _a;
+  try {
+    const raw = (_a = window.localStorage) == null ? void 0 : _a.getItem(
+      OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+    );
+    if (!raw) {
+      return void 0;
+    }
+    return normalizeObservabilityDevtoolsConfig(JSON.parse(raw));
+  } catch (e) {
+    return void 0;
+  }
+};
+const defineWritableGlobal = (key, value) => {
+  const targetWindow = getFederationWindow();
+  try {
+    Object.defineProperty(targetWindow, key, {
+      value,
+      configurable: true,
+      writable: true
+    });
+  } catch (e) {
+    targetWindow[key] = value;
+  }
+};
+const ensureFederationGlobal = () => {
+  var _a;
+  const targetWindow = getFederationWindow();
+  const federation = targetWindow.__FEDERATION__ || targetWindow.__VMOK__ || {};
+  if (!targetWindow.__FEDERATION__) {
+    defineWritableGlobal("__FEDERATION__", federation);
+  }
+  if (!targetWindow.__VMOK__) {
+    defineWritableGlobal("__VMOK__", targetWindow.__FEDERATION__);
+  }
+  if (!((_a = targetWindow.__FEDERATION__) == null ? void 0 : _a.__GLOBAL_PLUGIN__)) {
+    targetWindow.__FEDERATION__ = targetWindow.__FEDERATION__ || federation;
+    targetWindow.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
+  }
+  return targetWindow.__FEDERATION__;
+};
+const notifyInstalled = (status, reason, config) => {
+  try {
+    window.postMessage(
+      {
+        schemaVersion: 1,
+        source: OBSERVABILITY_DEVTOOLS_SOURCE,
+        kind: status,
+        reason,
+        config,
+        createdAt: Date.now()
+      },
+      "*"
+    );
+  } catch (e) {
+  }
+};
+const install = () => {
+  const config = safeReadStoredConfig();
+  if (!(config == null ? void 0 : config.enabled)) {
+    return;
+  }
+  const federation = ensureFederationGlobal();
+  const globalPlugins = (federation == null ? void 0 : federation.__GLOBAL_PLUGIN__) || [];
+  if (globalPlugins.some(
+    (plugin2) => (plugin2 == null ? void 0 : plugin2.name) === DEVTOOLS_PLUGIN_NAME || (plugin2 == null ? void 0 : plugin2.name) === LEGACY_DEVTOOLS_PLUGIN_NAME
+  )) {
+    notifyInstalled("skipped", "already-installed", config);
+    return;
+  }
+  const plugin = ChromeObservabilityPlugin(
+    createObservabilityPluginOptions(config)
+  );
+  globalPlugins.push(plugin);
+  federation.__GLOBAL_PLUGIN__ = globalPlugins;
+  notifyInstalled("installed", void 0, config);
+};
+install();