@module-federation/devtools 2.6.0 → 2.8.0

package/dist/types/init.js

@@ -0,0 +1,8 @@
+if (process.env.NODE_ENV === "development") {
+  const createProxy = () => new Proxy(() => Promise.resolve({}), {
+    get: () => {
+      return createProxy();
+    }
+  });
+  window.chrome = createProxy();
+}

package/dist/types/src/App.d.ts

@@ -3,5 +3,5 @@ import './App.css';
 import './init';
 import { RootComponentProps } from './utils';
 import '@arco-design/web-react/dist/css/arco.css';
-declare const App: (props: RootComponentProps) => import("react").JSX.Element;
+declare const App: (props: RootComponentProps) => import("node_modules/@types/react").JSX.Element;
 export default App;

package/dist/types/src/component/DependencyGraph/index.d.ts

@@ -2,5 +2,5 @@ import { GlobalModuleInfo } from '@module-federation/sdk';
 import 'reactflow/dist/style.css';
 declare const Graph: (props: {
     snapshot: GlobalModuleInfo;
-}) => import("react").JSX.Element;
+}) => import("node_modules/@types/react").JSX.Element;
 export default Graph;

package/dist/types/src/component/DependencyGraphItem/index.d.ts

@@ -5,5 +5,5 @@ declare const GraphItem: (props: {
         color?: string;
         remote?: any;
     };
-}) => import("react").JSX.Element;
+}) => import("node_modules/@types/react").JSX.Element;
 export default GraphItem;

package/dist/types/src/component/Form/index.d.ts

@@ -17,5 +17,5 @@ interface FormProps {
     onClipChange: (on: boolean) => void;
     headerSlot?: ReactNode;
 }
-declare const FormComponent: (props: FormProps & RootComponentProps) => import("react").JSX.Element;
+declare const FormComponent: (props: FormProps & RootComponentProps) => import("node_modules/@types/react").JSX.Element;
 export default FormComponent;

package/dist/types/src/component/LanguageSwitch.d.ts

@@ -1,2 +1,2 @@
-declare const LanguageSwitch: () => import("react").JSX.Element;
+declare const LanguageSwitch: () => import("node_modules/@types/react").JSX.Element;
 export default LanguageSwitch;

package/dist/types/src/component/Layout/index.d.ts

@@ -11,5 +11,5 @@ declare global {
 }
 declare const Layout: (props: {
     moduleInfo: GlobalModuleInfo;
-} & RootComponentProps) => import("react").JSX.Element;
+} & RootComponentProps) => import("node_modules/@types/react").JSX.Element;
 export default Layout;

package/dist/types/src/component/LoadingTrace/index.d.ts

@@ -2,5 +2,5 @@ interface LoadingTraceProps {
     tabId?: number;
     resetKey?: number;
 }
-declare const LoadingTrace: ({ tabId, resetKey }: LoadingTraceProps) => import("react").JSX.Element;
+declare const LoadingTrace: ({ tabId, resetKey }: LoadingTraceProps) => import("node_modules/@types/react").JSX.Element;
 export default LoadingTrace;

package/dist/types/src/component/ModuleInfo/index.d.ts

@@ -4,5 +4,5 @@ interface HomeProps {
     selectedModuleId: string | null;
     onSelectModule: (moduleId: string) => void;
 }
-declare const Home: (props: HomeProps) => import("react").JSX.Element;
+declare const Home: (props: HomeProps) => import("node_modules/@types/react").JSX.Element;
 export default Home;

package/dist/types/src/component/SharedDepsExplorer/index.d.ts

@@ -2,5 +2,5 @@ import type { GlobalShareScopeMap } from '@module-federation/runtime/types';
 interface SharedDepsExplorerProps {
     shareData?: GlobalShareScopeMap;
 }
-declare function SharedDepsExplorer({ shareData: shareDataProp, }: SharedDepsExplorerProps): import("react").JSX.Element;
+declare function SharedDepsExplorer({ shareData: shareDataProp, }: SharedDepsExplorerProps): import("node_modules/@types/react").JSX.Element;
 export default SharedDepsExplorer;

package/dist/types/src/component/SharedDepsExplorer/share-utils.d.ts

@@ -41,5 +41,5 @@ export declare function findPackageProvider(versions: NormalizedSharedVersion[],
     version: string;
     providers: string[];
     status: LoadedStatus;
-} | null;
+};
 export declare function getReusedVersions(versions: NormalizedSharedVersion[]): NormalizedSharedVersion[];

package/dist/types/src/i18n/index.d.ts

@@ -1,5 +1,5 @@
 import i18n from 'i18next';
 export declare const LANGUAGE_STORAGE_KEY = "mf-devtools-language";
-declare const supportedLanguages: readonly ["zh-CN", "en"];
+declare const supportedLanguages: readonly ['zh-CN', 'en'];
 export type SupportedLanguage = (typeof supportedLanguages)[number];
 export default i18n;

package/dist/types/src/template/constant.d.ts

@@ -8,7 +8,7 @@ export declare const defaultDataItem: {
     checked: boolean;
 };
 export declare const defaultModuleData: {
-    proxyFormField: never[];
+    proxyFormField: undefined[];
 };
 export declare const statusInfo: Record<string, {
     status: string;

package/dist/types/src/utils/chrome/index.d.ts

@@ -1,11 +1,12 @@
 import { GlobalModuleInfo } from '@module-federation/sdk';
 export * from './storage';
+export declare const normalizeModuleInfoPayload: (moduleInfo: unknown) => GlobalModuleInfo;
 export declare const injectPostMessage: (postMessageUrl: string) => void;
 export declare const TabInfo: {
     currentTabId: number;
 };
 export declare const setTargetTab: (tab?: chrome.tabs.Tab | null) => void;
-export declare const syncActiveTab: (tabId?: number) => Promise<chrome.tabs.Tab | undefined>;
+export declare const syncActiveTab: (tabId?: number) => Promise<chrome.tabs.Tab>;
 export declare function getCurrentTabId(): number;
 export declare function getInspectWindowTabId(): Promise<unknown>;
 export declare const refreshModuleInfo: () => Promise<void>;

package/dist/types/src/utils/chrome/observability.d.ts

@@ -107,4 +107,4 @@ export declare const disableObservabilityConfig: () => Promise<any>;
 export declare const reloadInspectedPage: () => Promise<any>;
 export declare const readObservabilitySnapshot: () => Promise<ObservabilityDevtoolsSnapshot>;
 export declare const mergeObservabilityReports: (currentReports: ObservabilityDevtoolsReport[], incomingReports: ObservabilityDevtoolsReport[]) => ObservabilityDevtoolsReport[];
-export declare const getObservabilityReportScopeLabel: (report: Pick<ObservabilityDevtoolsReport, "__scope">) => string | undefined;
+export declare const getObservabilityReportScopeLabel: (report: Pick<ObservabilityDevtoolsReport, '__scope'>) => string;

package/dist/types/src/utils/data/index.d.ts

@@ -1,6 +1,6 @@
 import { GlobalModuleInfo } from '@module-federation/sdk';
 export declare const separateType: (moduleInfo: GlobalModuleInfo) => {
-    consumers: Record<string, import("@module-federation/sdk").ModuleInfo | import("@module-federation/sdk").ManifestProvider | import("@module-federation/sdk").PureEntryProvider | undefined>;
+    consumers: Record<string, import("@module-federation/sdk").ManifestProvider | import("@module-federation/sdk").PureEntryProvider | import("@module-federation/sdk").ModuleInfo>;
     producer: string[];
 };
 export declare const getModuleInfo: (proxyRules: Array<any>) => Promise<{

package/dist/types/src/utils/sdk/graph.d.ts

@@ -40,7 +40,7 @@ export declare class DependencyGraph {
     createGraph(target?: string): void;
     addNode(id: string, type: string, x: number, y: number, nodeData: NodeCustomData): void;
     addEdge(id: string, source: string, target: string, type?: Edge): void;
-    run(targetGraph: any, target: string | undefined, type: string, id?: string, depth?: number, maxDepth?: number): void;
+    run(targetGraph: any, target: string, type: string, id?: string, depth?: number, maxDepth?: number): void;
     identify(): string;
     calculateDepth(target?: string, visited?: Set<string>): number;
 }

package/dist/types/src/utils/sdk/index.d.ts

@@ -1,11 +1,11 @@
 export * from './graph';
 export declare const setLocalStorage: (key: string, value: any) => void;
-export declare const getLocalStorage: (key: string) => string | null;
+export declare const getLocalStorage: (key: string) => string;
 export declare const removeLocalStorage: (key: string) => void;
 export declare const mergeLocalStorage: (target: string, key: string, value: any) => void;
 export declare const removeLocalStorageKey: (target: string, key: string) => void;
 export declare const isObject: (target: any) => boolean;
 export declare const reloadPage: () => void;
 export declare const validateCustom: (schema: string) => boolean;
-export declare const getUnpkgUrl: (pkg: string, version: string) => string | undefined;
+export declare const getUnpkgUrl: (pkg: string, version: string) => string;
 export declare const definePropertyGlobalVal: (target: Record<string, any>, key: string, val: any) => void;

package/dist/types/stories/index.stories.d.ts

@@ -1,9 +1,10 @@
 import React from 'react';
 import '../src/init';
 import '../mock';
+declare const Component: () => React.JSX.Element;
 declare const _default: {
     title: string;
-    component: () => React.JSX.Element;
+    component: typeof Component;
 };
 export default _default;
 export declare const Primary: {};

package/dist/types/template/constant.js

@@ -0,0 +1,84 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constant_exports = {};
+__export(constant_exports, {
+  BROWSER_ENV_KEY: () => BROWSER_ENV_KEY,
+  ENABLEHMR: () => ENABLEHMR,
+  ENABLE_CLIP: () => ENABLE_CLIP,
+  FormID: () => FormID,
+  __EAGER_SHARE__: () => __EAGER_SHARE__,
+  __ENABLE_FAST_REFRESH__: () => __ENABLE_FAST_REFRESH__,
+  __FEDERATION_DEVTOOLS__: () => __FEDERATION_DEVTOOLS__,
+  defaultDataItem: () => defaultDataItem,
+  defaultModuleData: () => defaultModuleData,
+  proxyFormField: () => proxyFormField,
+  statusInfo: () => statusInfo
+});
+module.exports = __toCommonJS(constant_exports);
+const FormID = "FormID";
+const ENABLEHMR = "enableHMR";
+const ENABLE_CLIP = "enableClip";
+const proxyFormField = "proxyFormField";
+const defaultDataItem = {
+  key: "",
+  value: "",
+  checked: true
+};
+const defaultModuleData = {
+  proxyFormField: []
+};
+const statusInfo = {
+  noProxy: {
+    status: "noProxy",
+    message: "Modules are not currently proxied",
+    color: "#698cee"
+  },
+  processing: {
+    status: "processing",
+    message: "Obtaining remote module information",
+    color: "#FF7D00"
+  },
+  success: {
+    status: "success",
+    message: "The proxy configuration has taken effect and the corresponding page has been automatically refreshed.",
+    color: "#50b042"
+  },
+  error: {
+    status: "error",
+    message: "Calculating Snapshot failed, please confirm whether the package information is correct",
+    color: "#F53F3F"
+  }
+};
+const __ENABLE_FAST_REFRESH__ = "enableFastRefresh";
+const __EAGER_SHARE__ = "eagerShare";
+const BROWSER_ENV_KEY = "MF_ENV";
+const __FEDERATION_DEVTOOLS__ = "__MF_DEVTOOLS__";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BROWSER_ENV_KEY,
+  ENABLEHMR,
+  ENABLE_CLIP,
+  FormID,
+  __EAGER_SHARE__,
+  __ENABLE_FAST_REFRESH__,
+  __FEDERATION_DEVTOOLS__,
+  defaultDataItem,
+  defaultModuleData,
+  proxyFormField,
+  statusInfo
+});

package/dist/types/template/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var template_exports = {};
+module.exports = __toCommonJS(template_exports);
+__reExport(template_exports, require("./constant"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./constant")
+});

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

@@ -0,0 +1,329 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var import__ = require("../index");
+var import_sdk = require("../sdk");
+var import_constant = require("../../template/constant");
+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[import_constant.__EAGER_SHARE__]);
+  const mergedScopes = Array.from(
+    /* @__PURE__ */ new Set([...(existing == null ? void 0 : existing.scopes) || [], ...scopes])
+  );
+  devtoolsMessage2[import_constant.__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((0, import__.getUnpkgUrl)(pkgName, version)),
+  pkgName,
+  scopes
+);
+const loadUmdModule = (pkgName, version, scopes) => __async(exports, null, function* () {
+  return executeUmdModule(
+    yield requestUmdSource((0, import__.getUnpkgUrl)(pkgName, version)),
+    pkgName,
+    scopes
+  );
+});
+const getDevtoolsMessage = () => {
+  const devtoolsMessageStr = localStorage.getItem(import_constant.__FEDERATION_DEVTOOLS__);
+  if (devtoolsMessageStr) {
+    try {
+      return JSON.parse(devtoolsMessageStr);
+    } catch (e) {
+      console.debug("Fast Refresh Plugin Error: ", e);
+    }
+  }
+  return null;
+};
+const devtoolsMessage = getDevtoolsMessage();
+const eagerShareInfo = getEagerShareInfo(devtoolsMessage == null ? void 0 : devtoolsMessage[import_constant.__EAGER_SHARE__]);
+if ((devtoolsMessage == null ? void 0 : devtoolsMessage[import_constant.__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;
+      }
+      const supportPkgName = pkgName;
+      const shareScopes = getShareScopes(shared.scope);
+      let enableFastRefresh = false;
+      let devtoolsMessage2 = {};
+      const devtoolsMessageStr = localStorage.getItem(import_constant.__FEDERATION_DEVTOOLS__);
+      if (devtoolsMessageStr) {
+        try {
+          devtoolsMessage2 = JSON.parse(devtoolsMessageStr);
+          enableFastRefresh = devtoolsMessage2 == null ? void 0 : devtoolsMessage2[import_constant.__ENABLE_FAST_REFRESH__];
+        } catch (e) {
+          console.debug("Fast Refresh Plugin Error: ", e);
+        }
+      }
+      if (!enableFastRefresh) {
+        return args;
+      }
+      if (((_a2 = shared.shareConfig) == null ? void 0 : _a2.eager) || shared.lib) {
+        if (!(devtoolsMessage2 == null ? void 0 : devtoolsMessage2[import_constant.__EAGER_SHARE__])) {
+          const eagerShareInfo2 = updateEagerShareInfo(
+            devtoolsMessage2,
+            pkgName,
+            shared.version,
+            shareScopes
+          );
+          localStorage.setItem(
+            import_constant.__FEDERATION_DEVTOOLS__,
+            JSON.stringify(devtoolsMessage2)
+          );
+          if (eagerShareInfo2.shouldReload) {
+            window.location.reload();
+          }
+        } else {
+          updateEagerShareInfo(
+            devtoolsMessage2,
+            pkgName,
+            shared.version,
+            shareScopes
+          );
+          localStorage.setItem(
+            import_constant.__FEDERATION_DEVTOOLS__,
+            JSON.stringify(devtoolsMessage2)
+          );
+        }
+        if (pkgName === "react-dom") {
+          shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+        }
+        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"
+              );
+            }
+            shared.lib = () => getScopeGlobal(supportPkgName, shareScopes);
+            return () => getScopeGlobal(supportPkgName, shareScopes);
+          });
+        }
+        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 args;
+    }
+  };
+};
+if (!(window == null ? void 0 : window.__FEDERATION__)) {
+  (0, import_sdk.definePropertyGlobalVal)(window, "__FEDERATION__", {});
+  (0, import_sdk.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());