@module-federation/devtools 0.0.0-chore-bump-node-22-20260710161714

package/dist/es/template/constant.js

@@ -0,0 +1,51 @@
+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__";
+export {
+  BROWSER_ENV_KEY,
+  ENABLEHMR,
+  ENABLE_CLIP,
+  FormID,
+  __EAGER_SHARE__,
+  __ENABLE_FAST_REFRESH__,
+  __FEDERATION_DEVTOOLS__,
+  defaultDataItem,
+  defaultModuleData,
+  proxyFormField,
+  statusInfo
+};

package/dist/es/template/index.js

@@ -0,0 +1 @@
+export * from "./constant";

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

@@ -0,0 +1,342 @@
+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) => {
+    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());
+  });
+};
+import { getUnpkgUrl } from "../index";
+import { definePropertyGlobalVal } from "../sdk";
+import {
+  __FEDERATION_DEVTOOLS__,
+  __EAGER_SHARE__,
+  __ENABLE_FAST_REFRESH__
+} from "../../template/constant";
+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])
+      );
+      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 {
+          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[__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;
+          }
+          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 (!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();
+              }
+            } else {
+              updateEagerShareInfo(
+                devtoolsMessage2,
+                pkgName,
+                shared.version,
+                shareScopes
+              );
+              localStorage.setItem(
+                __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__)) {
+      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());
+  }
+});
+export default require_fast_refresh();

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

@@ -0,0 +1,284 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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());
+  });
+};
+import { FormID } from "../../template/constant";
+import { definePropertyGlobalVal } from "../sdk";
+import { sanitizePostMessagePayload } from "./safe-post-message";
+export * from "./storage";
+const isModuleInfoRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isModuleInfoSyncMessage = (value) => isModuleInfoRecord(value) && ("moduleInfo" in value || "updateModule" in value || "share" in value);
+const normalizeModuleInfoPayload = (moduleInfo) => {
+  const sanitized = sanitizePostMessagePayload(moduleInfo);
+  if (!isModuleInfoRecord(sanitized)) {
+    return {};
+  }
+  return Object.entries(sanitized).reduce(
+    (moduleMap, [moduleId, snapshot]) => {
+      if (moduleId === "extendInfos" || isModuleInfoRecord(snapshot)) {
+        moduleMap[moduleId] = snapshot;
+      }
+      return moduleMap;
+    },
+    {}
+  );
+};
+const sleep = (num) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, num);
+  });
+};
+const injectPostMessage = (postMessageUrl) => {
+  const script = document.createElement("script");
+  script.src = postMessageUrl;
+  document.getElementsByTagName("head")[0].appendChild(script);
+};
+const TabInfo = {
+  currentTabId: 0
+};
+const setTargetTab = (tab) => {
+  if (!tab || typeof tab.id !== "number") {
+    return;
+  }
+  window.targetTab = tab;
+  TabInfo.currentTabId = tab.id;
+};
+const syncActiveTab = (tabId) => __async(void 0, null, function* () {
+  try {
+    if (typeof tabId === "number") {
+      const tab = yield chrome.tabs.get(tabId);
+      setTargetTab(tab);
+      return tab;
+    }
+    const tabs = yield getTabs({
+      active: true,
+      lastFocusedWindow: true
+    });
+    const activeTab = Array.isArray(tabs) ? tabs[0] : void 0;
+    setTargetTab(activeTab);
+    return activeTab;
+  } catch (error) {
+    console.warn("[Module Federation Devtools] syncActiveTab failed", error);
+    return void 0;
+  }
+});
+function getCurrentTabId() {
+  return TabInfo.currentTabId;
+}
+function getInspectWindowTabId() {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    if ((_a = chrome == null ? void 0 : chrome.devtools) == null ? void 0 : _a.inspectedWindow) {
+      if (chrome.isDevMode) {
+        resolve(0);
+      }
+      chrome.devtools.inspectedWindow.eval(
+        'typeof window.__FEDERATION__ !== "undefined" || typeof window.__VMOK__ !== "undefined"',
+        function(info, error) {
+          const { tabId } = chrome.devtools.inspectedWindow;
+          getTabs().then((tabs) => {
+            const target = Array.isArray(tabs) ? tabs.find((tab) => tab.id === tabId) : void 0;
+            setTargetTab(target);
+          });
+          console.log(
+            "chrome.devtools.inspectedWindow.tabId",
+            chrome.devtools.inspectedWindow.tabId
+          );
+          TabInfo.currentTabId = tabId;
+          resolve(tabId);
+          if (error) {
+            reject(error);
+          }
+        }
+      );
+    } else {
+      if ((_b = window.targetTab) == null ? void 0 : _b.id) {
+        const tabId = window.targetTab.id;
+        TabInfo.currentTabId = tabId;
+        resolve(tabId);
+      } else {
+        throw Error(`can't get active tab`);
+      }
+    }
+  });
+}
+const refreshModuleInfo = () => __async(void 0, null, function* () {
+  var _a;
+  if (typeof window !== "undefined" && ((_a = window.__FEDERATION__) == null ? void 0 : _a.moduleInfo)) {
+  }
+  yield sleep(50);
+  const postMessageStartUrl = getUrl("post-message-start.js");
+  yield injectScript(injectPostMessage, false, postMessageStartUrl);
+});
+const getGlobalModuleInfo = (callback) => __async(void 0, null, function* () {
+  var _a, _b;
+  if (typeof window !== "undefined" && ((_a = window.__FEDERATION__) == null ? void 0 : _a.moduleInfo)) {
+    callback(normalizeModuleInfoPayload((_b = window.__FEDERATION__) == null ? void 0 : _b.moduleInfo));
+  }
+  yield sleep(300);
+  const listener = (message) => {
+    const { data } = message;
+    if (!isModuleInfoSyncMessage(data) || (data == null ? void 0 : data.appInfos)) {
+      return;
+    }
+    if (!(window == null ? void 0 : window.__FEDERATION__)) {
+      definePropertyGlobalVal(window, "__FEDERATION__", {});
+      definePropertyGlobalVal(window, "__VMOK__", window.__FEDERATION__);
+    }
+    window.__FEDERATION__.originModuleInfo = "moduleInfo" in data ? normalizeModuleInfoPayload(data.moduleInfo) : normalizeModuleInfoPayload(
+      window.__FEDERATION__.originModuleInfo || window.__FEDERATION__.moduleInfo
+    );
+    const updateModule = data.updateModule;
+    if (isModuleInfoRecord(updateModule) && typeof updateModule.name === "string") {
+      const updateModuleName = updateModule.name;
+      const moduleIds = Object.keys(window.__FEDERATION__.originModuleInfo);
+      const shouldUpdate = !moduleIds.some(
+        (id) => id.includes(updateModuleName)
+      );
+      if (shouldUpdate) {
+        const destination = typeof updateModule.entry === "string" ? updateModule.entry : typeof updateModule.version === "string" ? updateModule.version : void 0;
+        if (destination) {
+          window.__FEDERATION__.originModuleInfo[`${updateModuleName}:${destination}`] = {
+            remoteEntry: destination,
+            version: destination
+          };
+        }
+      }
+    }
+    if (data == null ? void 0 : data.share) {
+      window.__FEDERATION__.__SHARE__ = sanitizePostMessagePayload(
+        data.share
+      );
+    }
+    window.__FEDERATION__.moduleInfo = normalizeModuleInfoPayload(
+      window.__FEDERATION__.originModuleInfo
+    );
+    console.log("getGlobalModuleInfo window", window.__FEDERATION__);
+    callback(window.__FEDERATION__.moduleInfo);
+  };
+  chrome.runtime.onMessage.addListener(listener);
+  yield refreshModuleInfo();
+  return () => chrome.runtime.onMessage.removeListener(listener);
+});
+const getTabs = (queryOptions = {}) => chrome.tabs.query(queryOptions);
+const getScope = () => __async(void 0, null, function* () {
+  const activeTab = window.targetTab;
+  const tabId = activeTab == null ? void 0 : activeTab.id;
+  return tabId ? String(tabId) : "noScope";
+});
+const injectScript = (excuteScript, world = false, ...args) => __async(void 0, null, function* () {
+  yield getInspectWindowTabId();
+  return chrome.scripting.executeScript({
+    target: {
+      tabId: getCurrentTabId()
+    },
+    func: excuteScript,
+    world: world ? "MAIN" : "ISOLATED",
+    args
+  }).then((results) => {
+    var _a;
+    console.log("InjectScript success, excuteScript:", args);
+    if (Array.isArray(results) && results.length) {
+      return (_a = results[0]) == null ? void 0 : _a.result;
+    }
+    return void 0;
+  }).catch((e) => {
+    console.log(e, "InjectScript fail, excuteScript:", args);
+    return void 0;
+  });
+});
+const getUrl = (file) => {
+  try {
+    const pathSet = chrome.runtime.getURL(file).split("/");
+    const fileName = pathSet.pop();
+    pathSet.push("static", "js", fileName);
+    return pathSet.join("/");
+  } catch (e) {
+    return "";
+  }
+};
+const injectToast = (toastUtilUrl, e2eFlag) => {
+  const ele = document.querySelector(`[data-e2e=${e2eFlag}]`);
+  if (ele) {
+    return;
+  }
+  const scriptToast = document.createElement("script");
+  scriptToast.src = toastUtilUrl;
+  scriptToast.dataset.e2e = e2eFlag;
+  document.getElementsByTagName("head")[0].appendChild(scriptToast);
+};
+const setChromeStorage = (formData) => {
+  getScope().then((scope) => __async(void 0, null, function* () {
+    const data = yield chrome.storage.sync.get("FormID");
+    const storeData = data[FormID];
+    const scopes = Object.keys(storeData || {});
+    let filterOutDatedData = storeData || {};
+    const { length } = scopes;
+    if (length >= 10) {
+      filterOutDatedData = scopes.slice(0, length - 3).reduce((memo, cur) => {
+        memo[cur] = storeData[cur];
+        return memo;
+      }, {});
+    }
+    const existRules = storeData == null ? void 0 : storeData[scope];
+    chrome.storage.sync.set({
+      [FormID]: __spreadProps(__spreadValues({}, filterOutDatedData), {
+        [scope]: __spreadValues(__spreadValues({}, existRules), formData)
+      })
+    });
+  }));
+};
+export {
+  TabInfo,
+  getCurrentTabId,
+  getGlobalModuleInfo,
+  getInspectWindowTabId,
+  getScope,
+  getTabs,
+  getUrl,
+  injectPostMessage,
+  injectScript,
+  injectToast,
+  normalizeModuleInfoPayload,
+  refreshModuleInfo,
+  setChromeStorage,
+  setTargetTab,
+  syncActiveTab
+};

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

@@ -0,0 +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_OBSERVABILITY_DEVTOOLS_EVENT,
+  MESSAGE_OPEN_SIDE_PANEL,
+  OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+};